mirror of
https://github.com/c64scene-ar/llvm-6502.git
synced 2024-08-17 05:29:24 +00:00
Keep tabs and trailing spaces out.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@22565 91177308-0d34-0410-b5e6-96231b3b80d8
This commit is contained in:
parent
cfb1d4235f
commit
d29b6aa608
@ -42,10 +42,10 @@ namespace llvm {
|
||||
SCEVExpander(ScalarEvolution &se, LoopInfo &li) : SE(se), LI(li) {}
|
||||
|
||||
/// clear - Erase the contents of the InsertedExpressions map so that users
|
||||
/// trying to expand the same expression into multiple BasicBlocks or
|
||||
/// trying to expand the same expression into multiple BasicBlocks or
|
||||
/// different places within the same BasicBlock can do so.
|
||||
void clear() { InsertedExpressions.clear(); }
|
||||
|
||||
|
||||
/// isInsertedInstruction - Return true if the specified instruction was
|
||||
/// inserted by the code rewriter. If so, the client should not modify the
|
||||
/// instruction.
|
||||
|
@ -271,14 +271,14 @@ SDOperand SelectionDAGLegalize::PromoteLegalFP_TO_INT(SDOperand LegalOp,
|
||||
bool isSigned) {
|
||||
// First step, figure out the appropriate FP_TO*INT operation to use.
|
||||
MVT::ValueType NewOutTy = DestVT;
|
||||
|
||||
|
||||
unsigned OpToUse = 0;
|
||||
|
||||
|
||||
// Scan for the appropriate larger type to use.
|
||||
while (1) {
|
||||
NewOutTy = (MVT::ValueType)(NewOutTy+1);
|
||||
assert(MVT::isInteger(NewOutTy) && "Ran out of possibilities!");
|
||||
|
||||
|
||||
// If the target supports FP_TO_SINT returning this type, use it.
|
||||
switch (TLI.getOperationAction(ISD::FP_TO_SINT, NewOutTy)) {
|
||||
default: break;
|
||||
@ -291,7 +291,7 @@ SDOperand SelectionDAGLegalize::PromoteLegalFP_TO_INT(SDOperand LegalOp,
|
||||
break;
|
||||
}
|
||||
if (OpToUse) break;
|
||||
|
||||
|
||||
// If the target supports FP_TO_UINT of this type, use it.
|
||||
switch (TLI.getOperationAction(ISD::FP_TO_UINT, NewOutTy)) {
|
||||
default: break;
|
||||
@ -304,13 +304,13 @@ SDOperand SelectionDAGLegalize::PromoteLegalFP_TO_INT(SDOperand LegalOp,
|
||||
break;
|
||||
}
|
||||
if (OpToUse) break;
|
||||
|
||||
|
||||
// Otherwise, try a larger type.
|
||||
}
|
||||
|
||||
|
||||
// Make sure to legalize any nodes we create here in the next pass.
|
||||
NeedsAnotherIteration = true;
|
||||
|
||||
|
||||
// Okay, we found the operation and type to use. Truncate the result of the
|
||||
// extended FP_TO_*INT operation to the desired size.
|
||||
return DAG.getNode(ISD::TRUNCATE, DestVT,
|
||||
@ -1502,7 +1502,7 @@ SDOperand SelectionDAGLegalize::LegalizeOp(SDOperand Op) {
|
||||
bool isSigned = Node->getOpcode() == ISD::SINT_TO_FP;
|
||||
switch (getTypeAction(Node->getOperand(0).getValueType())) {
|
||||
case Legal:
|
||||
switch (TLI.getOperationAction(Node->getOpcode(),
|
||||
switch (TLI.getOperationAction(Node->getOpcode(),
|
||||
Node->getOperand(0).getValueType())) {
|
||||
default: assert(0 && "Unknown operation action!");
|
||||
case TargetLowering::Expand:
|
||||
@ -1565,7 +1565,7 @@ SDOperand SelectionDAGLegalize::LegalizeOp(SDOperand Op) {
|
||||
break;
|
||||
}
|
||||
break;
|
||||
|
||||
|
||||
case ISD::FP_TO_SINT:
|
||||
case ISD::FP_TO_UINT:
|
||||
switch (getTypeAction(Node->getOperand(0).getValueType())) {
|
||||
@ -1590,7 +1590,7 @@ SDOperand SelectionDAGLegalize::LegalizeOp(SDOperand Op) {
|
||||
NeedsAnotherIteration = true;
|
||||
return Result;
|
||||
}
|
||||
|
||||
|
||||
if (Tmp1 != Node->getOperand(0))
|
||||
Result = DAG.getNode(Node->getOpcode(), Node->getValueType(0), Tmp1);
|
||||
break;
|
||||
@ -1602,7 +1602,7 @@ SDOperand SelectionDAGLegalize::LegalizeOp(SDOperand Op) {
|
||||
break;
|
||||
}
|
||||
break;
|
||||
|
||||
|
||||
case ISD::ZERO_EXTEND:
|
||||
case ISD::SIGN_EXTEND:
|
||||
case ISD::FP_EXTEND:
|
||||
@ -2785,7 +2785,7 @@ void SelectionDAGLegalize::ExpandOp(SDOperand Op, SDOperand &Lo, SDOperand &Hi){
|
||||
case Legal: Op = LegalizeOp(Node->getOperand(0)); break;
|
||||
case Promote: Op = PromoteOp(Node->getOperand(0)); break;
|
||||
}
|
||||
|
||||
|
||||
Op = TLI.LowerOperation(DAG.getNode(ISD::FP_TO_SINT, VT, Op), DAG);
|
||||
|
||||
// Now that the custom expander is done, expand the result, which is still
|
||||
@ -2793,12 +2793,13 @@ void SelectionDAGLegalize::ExpandOp(SDOperand Op, SDOperand &Lo, SDOperand &Hi){
|
||||
ExpandOp(Op, Lo, Hi);
|
||||
break;
|
||||
}
|
||||
|
||||
|
||||
if (Node->getOperand(0).getValueType() == MVT::f32)
|
||||
Lo = ExpandLibCall("__fixsfdi", Node, Hi);
|
||||
else
|
||||
Lo = ExpandLibCall("__fixdfdi", Node, Hi);
|
||||
break;
|
||||
|
||||
case ISD::FP_TO_UINT:
|
||||
if (TLI.getOperationAction(ISD::FP_TO_UINT, VT) == TargetLowering::Custom) {
|
||||
SDOperand Op = DAG.getNode(ISD::FP_TO_UINT, VT,
|
||||
@ -2808,7 +2809,7 @@ void SelectionDAGLegalize::ExpandOp(SDOperand Op, SDOperand &Lo, SDOperand &Hi){
|
||||
ExpandOp(TLI.LowerOperation(Op, DAG), Lo, Hi);
|
||||
break;
|
||||
}
|
||||
|
||||
|
||||
if (Node->getOperand(0).getValueType() == MVT::f32)
|
||||
Lo = ExpandLibCall("__fixunssfdi", Node, Hi);
|
||||
else
|
||||
|
@ -65,7 +65,7 @@ namespace {
|
||||
inline unsigned char *allocateStub(unsigned StubSize);
|
||||
inline unsigned char *allocateConstant(unsigned ConstantSize,
|
||||
unsigned Alignment);
|
||||
inline unsigned char* allocateGlobal(unsigned Size,
|
||||
inline unsigned char* allocateGlobal(unsigned Size,
|
||||
unsigned Alignment);
|
||||
inline unsigned char *startFunctionBody();
|
||||
inline void endFunctionBody(unsigned char *FunctionEnd);
|
||||
@ -373,8 +373,8 @@ void *JITResolver::JITCompilerFn(void *Stub) {
|
||||
|
||||
// FIXME: We could rewrite all references to this stub if we knew them.
|
||||
|
||||
// What we will do is set the compiled function address to map to the
|
||||
// same GOT entry as the stub so that later clients may update the GOT
|
||||
// What we will do is set the compiled function address to map to the
|
||||
// same GOT entry as the stub so that later clients may update the GOT
|
||||
// if they see it still using the stub address.
|
||||
// Note: this is done so the Resolver doesn't have to manage GOT memory
|
||||
// Do this without allocating map space if the target isn't using a GOT
|
||||
@ -548,7 +548,7 @@ void JITEmitter::finishFunction(MachineFunction &F) {
|
||||
if(MemMgr.isManagingGOT()) {
|
||||
unsigned idx = getJITResolver(this).getGOTIndexForAddr((void*)CurBlock);
|
||||
if (((void**)MemMgr.getGOTBase())[idx] != (void*)CurBlock) {
|
||||
DEBUG(std::cerr << "GOT was out of date for " << (void*)CurBlock
|
||||
DEBUG(std::cerr << "GOT was out of date for " << (void*)CurBlock
|
||||
<< " pointing at " << ((void**)MemMgr.getGOTBase())[idx] << "\n");
|
||||
((void**)MemMgr.getGOTBase())[idx] = (void*)CurBlock;
|
||||
}
|
||||
|
@ -92,7 +92,7 @@ extern "C" {
|
||||
EmitBranchToAt(CameFromStub, Target);
|
||||
} else {
|
||||
DEBUG(std::cerr << "confused, didn't come from stub at " << CameFromStub
|
||||
<< " old jump vector " << oldpv
|
||||
<< " old jump vector " << oldpv
|
||||
<< " new jump vector " << Target << "\n");
|
||||
}
|
||||
|
||||
@ -291,7 +291,7 @@ void AlphaJITInfo::relocate(void *Function, MachineRelocation *MR,
|
||||
}
|
||||
break;
|
||||
case Alpha::reloc_bsr: {
|
||||
idx = (((unsigned char*)MR->getResultPointer() -
|
||||
idx = (((unsigned char*)MR->getResultPointer() -
|
||||
(unsigned char*)RelocPos) >> 2) + 1; //skip first 2 inst of fun
|
||||
*RelocPos |= (idx & ((1 << 21)-1));
|
||||
doCommon = false;
|
||||
|
@ -245,7 +245,7 @@ void PPC32RegisterInfo::emitPrologue(MachineFunction &MF) const {
|
||||
NumBytes += MFI->getMaxCallFrameSize();
|
||||
}
|
||||
|
||||
// If we are a leaf function, and use up to 224 bytes of stack space,
|
||||
// If we are a leaf function, and use up to 224 bytes of stack space,
|
||||
// and don't have a frame pointer, then we do not need to adjust the stack
|
||||
// pointer (we fit in the Red Zone).
|
||||
if ((NumBytes == 0) || (NumBytes <= 224 && !hasFP(MF) && !MFI->hasCalls())) {
|
||||
|
@ -62,7 +62,7 @@ namespace {
|
||||
FP_TO_INT16_IN_MEM,
|
||||
FP_TO_INT32_IN_MEM,
|
||||
FP_TO_INT64_IN_MEM,
|
||||
|
||||
|
||||
/// CALL/TAILCALL - These operations represent an abstract X86 call
|
||||
/// instruction, which includes a bunch of information. In particular the
|
||||
/// operands of these node are:
|
||||
@ -135,7 +135,7 @@ namespace {
|
||||
setOperationAction(ISD::FP_TO_SINT , MVT::i32 , Custom);
|
||||
setOperationAction(ISD::FP_TO_SINT , MVT::i16 , Custom);
|
||||
}
|
||||
|
||||
|
||||
// Handle FP_TO_UINT by promoting the destination to a larger signed
|
||||
// conversion.
|
||||
setOperationAction(ISD::FP_TO_UINT , MVT::i1 , Promote);
|
||||
@ -147,7 +147,7 @@ namespace {
|
||||
// this operation.
|
||||
setOperationAction(ISD::FP_TO_SINT , MVT::i1 , Promote);
|
||||
setOperationAction(ISD::FP_TO_SINT , MVT::i8 , Promote);
|
||||
|
||||
|
||||
setOperationAction(ISD::BRCONDTWOWAY , MVT::Other, Expand);
|
||||
setOperationAction(ISD::MEMMOVE , MVT::Other, Expand);
|
||||
setOperationAction(ISD::SIGN_EXTEND_INREG, MVT::i16 , Expand);
|
||||
@ -1008,14 +1008,14 @@ SDOperand X86TargetLowering::LowerOperation(SDOperand Op, SelectionDAG &DAG) {
|
||||
case MVT::i32: Opc = X86ISD::FP_TO_INT32_IN_MEM; break;
|
||||
case MVT::i64: Opc = X86ISD::FP_TO_INT64_IN_MEM; break;
|
||||
}
|
||||
|
||||
|
||||
// Build the FP_TO_INT*_IN_MEM
|
||||
std::vector<SDOperand> Ops;
|
||||
Ops.push_back(DAG.getEntryNode());
|
||||
Ops.push_back(Op.getOperand(0));
|
||||
Ops.push_back(StackSlot);
|
||||
SDOperand FIST = DAG.getNode(Opc, MVT::Other, Ops);
|
||||
|
||||
|
||||
// Load the result.
|
||||
return DAG.getLoad(Op.getValueType(), FIST, StackSlot,
|
||||
DAG.getSrcValue(NULL));
|
||||
@ -3308,7 +3308,7 @@ unsigned ISel::SelectExpr(SDOperand N) {
|
||||
addFullAddress(BuildMI(BB, X86::FILD64m, 4, Result), AM);
|
||||
}
|
||||
return Result;
|
||||
|
||||
|
||||
case ISD::EXTLOAD: // Arbitrarily codegen extloads as MOVZX*
|
||||
case ISD::ZEXTLOAD: {
|
||||
// Make sure we generate both values.
|
||||
@ -4307,7 +4307,7 @@ void ISel::Select(SDOperand N) {
|
||||
ExprMap.erase(N);
|
||||
SelectExpr(N.getValue(0));
|
||||
return;
|
||||
|
||||
|
||||
case X86ISD::FP_TO_INT16_IN_MEM:
|
||||
case X86ISD::FP_TO_INT32_IN_MEM:
|
||||
case X86ISD::FP_TO_INT64_IN_MEM: {
|
||||
@ -4323,24 +4323,24 @@ void ISel::Select(SDOperand N) {
|
||||
SelectAddress(N.getOperand(2), AM);
|
||||
ValReg = SelectExpr(N.getOperand(1));
|
||||
}
|
||||
|
||||
|
||||
// Change the floating point control register to use "round towards zero"
|
||||
// mode when truncating to an integer value.
|
||||
//
|
||||
MachineFunction *F = BB->getParent();
|
||||
int CWFrameIdx = F->getFrameInfo()->CreateStackObject(2, 2);
|
||||
addFrameReference(BuildMI(BB, X86::FNSTCW16m, 4), CWFrameIdx);
|
||||
|
||||
|
||||
// Load the old value of the high byte of the control word...
|
||||
unsigned OldCW = MakeReg(MVT::i16);
|
||||
addFrameReference(BuildMI(BB, X86::MOV16rm, 4, OldCW), CWFrameIdx);
|
||||
|
||||
|
||||
// Set the high part to be round to zero...
|
||||
addFrameReference(BuildMI(BB, X86::MOV16mi, 5), CWFrameIdx).addImm(0xC7F);
|
||||
|
||||
|
||||
// Reload the modified control word now...
|
||||
addFrameReference(BuildMI(BB, X86::FLDCW16m, 4), CWFrameIdx);
|
||||
|
||||
|
||||
// Restore the memory image of control word to original value
|
||||
addFrameReference(BuildMI(BB, X86::MOV16mr, 5), CWFrameIdx).addReg(OldCW);
|
||||
|
||||
@ -4350,9 +4350,9 @@ void ISel::Select(SDOperand N) {
|
||||
case X86ISD::FP_TO_INT32_IN_MEM: Tmp1 = X86::FIST32m; break;
|
||||
case X86ISD::FP_TO_INT64_IN_MEM: Tmp1 = X86::FISTP64m; break;
|
||||
}
|
||||
|
||||
|
||||
addFullAddress(BuildMI(BB, Tmp1, 5), AM).addReg(ValReg);
|
||||
|
||||
|
||||
// Reload the original control word now.
|
||||
addFrameReference(BuildMI(BB, X86::FLDCW16m, 4), CWFrameIdx);
|
||||
return;
|
||||
|
@ -172,7 +172,7 @@ static bool CanReduceSCEV(const SCEVHandle &SH, Loop *L) {
|
||||
if (SCEVUnknown *SU = dyn_cast<SCEVUnknown>(AddRec->getOperand(1)))
|
||||
if (SU->getValue()->getType()->isUnsigned())
|
||||
return true;
|
||||
|
||||
|
||||
// Otherwise, no, we can't handle it yet.
|
||||
return false;
|
||||
}
|
||||
@ -192,7 +192,7 @@ static SCEVHandle GetAdjustedIndex(const SCEVHandle &Idx, uint64_t TySize,
|
||||
|
||||
// This index is scaled by the type size being indexed.
|
||||
if (TySize != 1)
|
||||
Result = SCEVMulExpr::get(Result,
|
||||
Result = SCEVMulExpr::get(Result,
|
||||
SCEVConstant::get(ConstantUInt::get(UIntPtrTy,
|
||||
TySize)));
|
||||
return Result;
|
||||
@ -216,7 +216,7 @@ void LoopStrengthReduce::AnalyzeGetElementPtrUsers(GetElementPtrInst *GEP,
|
||||
Value *BasePtr;
|
||||
if (Constant *CB = dyn_cast<Constant>(GEP->getOperand(0)))
|
||||
BasePtr = ConstantExpr::getCast(CB, UIntPtrTy);
|
||||
else {
|
||||
else {
|
||||
Value *&BP = CastedBasePointers[GEP->getOperand(0)];
|
||||
if (BP == 0) {
|
||||
BasicBlock::iterator InsertPt;
|
||||
@ -321,7 +321,7 @@ void LoopStrengthReduce::AnalyzeGetElementPtrUsers(GetElementPtrInst *GEP,
|
||||
DEBUG(std::cerr << "FOUND USER: " << *User
|
||||
<< " OF STRIDE: " << *Step << " BASE = " << *Base << "\n");
|
||||
|
||||
|
||||
|
||||
// Okay, we found a user that we cannot reduce. Analyze the instruction
|
||||
// and decide what to do with it.
|
||||
IVUsesByStride[Step].addUser(Base, User, GEP);
|
||||
@ -351,7 +351,7 @@ bool LoopStrengthReduce::AddUsersIfInteresting(Instruction *I, Loop *L) {
|
||||
assert(Step->getType()->isUnsigned() && "Bad step value!");
|
||||
|
||||
std::set<GetElementPtrInst*> AnalyzedGEPs;
|
||||
|
||||
|
||||
for (Value::use_iterator UI = I->use_begin(), E = I->use_end(); UI != E;++UI){
|
||||
Instruction *User = cast<Instruction>(*UI);
|
||||
|
||||
@ -364,12 +364,12 @@ bool LoopStrengthReduce::AddUsersIfInteresting(Instruction *I, Loop *L) {
|
||||
if (LI->getLoopFor(User->getParent()) != L)
|
||||
continue;
|
||||
|
||||
// Next, see if this user is analyzable itself!
|
||||
// Next, see if this user is analyzable itself!
|
||||
if (!AddUsersIfInteresting(User, L)) {
|
||||
if (GetElementPtrInst *GEP = dyn_cast<GetElementPtrInst>(User)) {
|
||||
// If this is a getelementptr instruction, figure out what linear
|
||||
// expression of induction variable is actually being used.
|
||||
//
|
||||
//
|
||||
if (AnalyzedGEPs.insert(GEP).second) // Not already analyzed?
|
||||
AnalyzeGetElementPtrUsers(GEP, I, L);
|
||||
} else {
|
||||
@ -426,12 +426,12 @@ void BasedUser::dump() const {
|
||||
/// isTargetConstant - Return true if the following can be referenced by the
|
||||
/// immediate field of a target instruction.
|
||||
static bool isTargetConstant(const SCEVHandle &V) {
|
||||
|
||||
|
||||
// FIXME: Look at the target to decide if &GV is a legal constant immediate.
|
||||
if (isa<SCEVConstant>(V)) return true;
|
||||
|
||||
|
||||
return false; // ENABLE this for x86
|
||||
|
||||
|
||||
if (SCEVUnknown *SU = dyn_cast<SCEVUnknown>(V))
|
||||
if (ConstantExpr *CE = dyn_cast<ConstantExpr>(SU->getValue()))
|
||||
if (CE->getOpcode() == Instruction::Cast)
|
||||
@ -455,7 +455,7 @@ static SCEVHandle GetImmediateValues(SCEVHandle Val, bool isAddress) {
|
||||
for (; i != SAE->getNumOperands(); ++i)
|
||||
if (isTargetConstant(SAE->getOperand(i))) {
|
||||
SCEVHandle ImmVal = SAE->getOperand(i);
|
||||
|
||||
|
||||
// If there are any other immediates that we can handle here, pull them
|
||||
// out too.
|
||||
for (++i; i != SAE->getNumOperands(); ++i)
|
||||
@ -481,8 +481,8 @@ void LoopStrengthReduce::StrengthReduceStridedIVUsers(Value *Stride,
|
||||
// eventually emit the object.
|
||||
std::vector<std::pair<SCEVHandle, BasedUser> > UsersToProcess;
|
||||
UsersToProcess.reserve(Uses.Users.size());
|
||||
|
||||
SCEVHandle ZeroBase = SCEVUnknown::getIntegerSCEV(0,
|
||||
|
||||
SCEVHandle ZeroBase = SCEVUnknown::getIntegerSCEV(0,
|
||||
Uses.Users[0].first->getType());
|
||||
|
||||
for (unsigned i = 0, e = Uses.Users.size(); i != e; ++i)
|
||||
@ -497,7 +497,7 @@ void LoopStrengthReduce::StrengthReduceStridedIVUsers(Value *Stride,
|
||||
for (unsigned i = 0, e = UsersToProcess.size(); i != e; ++i) {
|
||||
bool isAddress = isa<LoadInst>(UsersToProcess[i].second.Inst) ||
|
||||
isa<StoreInst>(UsersToProcess[i].second.Inst);
|
||||
UsersToProcess[i].second.Imm = GetImmediateValues(UsersToProcess[i].first,
|
||||
UsersToProcess[i].second.Imm = GetImmediateValues(UsersToProcess[i].first,
|
||||
isAddress);
|
||||
UsersToProcess[i].first = SCEV::getMinusSCEV(UsersToProcess[i].first,
|
||||
UsersToProcess[i].second.Imm);
|
||||
@ -511,14 +511,14 @@ void LoopStrengthReduce::StrengthReduceStridedIVUsers(Value *Stride,
|
||||
Instruction *PreInsertPt = Preheader->getTerminator();
|
||||
Instruction *PhiInsertBefore = L->getHeader()->begin();
|
||||
|
||||
assert(isa<PHINode>(PhiInsertBefore) &&
|
||||
assert(isa<PHINode>(PhiInsertBefore) &&
|
||||
"How could this loop have IV's without any phis?");
|
||||
PHINode *SomeLoopPHI = cast<PHINode>(PhiInsertBefore);
|
||||
assert(SomeLoopPHI->getNumIncomingValues() == 2 &&
|
||||
"This loop isn't canonicalized right");
|
||||
BasicBlock *LatchBlock =
|
||||
SomeLoopPHI->getIncomingBlock(SomeLoopPHI->getIncomingBlock(0) == Preheader);
|
||||
|
||||
|
||||
// FIXME: This loop needs increasing levels of intelligence.
|
||||
// STAGE 0: just emit everything as its own base. <-- We are here
|
||||
// STAGE 1: factor out common vars from bases, and try and push resulting
|
||||
@ -534,7 +534,7 @@ void LoopStrengthReduce::StrengthReduceStridedIVUsers(Value *Stride,
|
||||
PHINode *NewPHI = new PHINode(ReplacedTy, Replaced->getName()+".str",
|
||||
PhiInsertBefore);
|
||||
|
||||
// Emit the initial base value into the loop preheader, and add it to the
|
||||
// Emit the initial base value into the loop preheader, and add it to the
|
||||
// Phi node.
|
||||
Value *BaseV = Rewriter.expandCodeFor(UsersToProcess.front().first,
|
||||
PreInsertPt, ReplacedTy);
|
||||
@ -552,7 +552,7 @@ void LoopStrengthReduce::StrengthReduceStridedIVUsers(Value *Stride,
|
||||
|
||||
// Emit the code to add the immediate offset to the Phi value, just before
|
||||
// the instruction that we identified as using this stride and base.
|
||||
// First, empty the SCEVExpander's expression map so that we are guaranteed
|
||||
// First, empty the SCEVExpander's expression map so that we are guaranteed
|
||||
// to have the code emitted where we expect it.
|
||||
Rewriter.clear();
|
||||
SCEVHandle NewValSCEV = SCEVAddExpr::get(SCEVUnknown::get(NewPHI),
|
||||
@ -560,16 +560,16 @@ void LoopStrengthReduce::StrengthReduceStridedIVUsers(Value *Stride,
|
||||
Value *newVal = Rewriter.expandCodeFor(NewValSCEV,
|
||||
UsersToProcess.front().second.Inst,
|
||||
ReplacedTy);
|
||||
|
||||
|
||||
// Replace the use of the operand Value with the new Phi we just created.
|
||||
DEBUG(std::cerr << "REPLACING: " << *Replaced << "IN: " <<
|
||||
DEBUG(std::cerr << "REPLACING: " << *Replaced << "IN: " <<
|
||||
*UsersToProcess.front().second.Inst << "WITH: "<< *newVal << '\n');
|
||||
UsersToProcess.front().second.Inst->replaceUsesOfWith(Replaced, newVal);
|
||||
|
||||
|
||||
// Mark old value we replaced as possibly dead, so that it is elminated
|
||||
// if we just replaced the last use of that value.
|
||||
DeadInsts.insert(cast<Instruction>(Replaced));
|
||||
|
||||
|
||||
UsersToProcess.erase(UsersToProcess.begin());
|
||||
++NumReduced;
|
||||
|
||||
@ -578,7 +578,7 @@ void LoopStrengthReduce::StrengthReduceStridedIVUsers(Value *Stride,
|
||||
|
||||
// IMPORTANT TODO: Figure out how to partition the IV's with this stride, but
|
||||
// different starting values, into different PHIs.
|
||||
|
||||
|
||||
// BEFORE writing this, it's probably useful to handle GEP's.
|
||||
|
||||
// NOTE: pull all constants together, for REG+IMM addressing, include &GV in
|
||||
|
@ -65,7 +65,7 @@ cl::list<const PassInfo*, bool, FilteredPassNameParser<PassInfo::LLC> >
|
||||
LLCPassList(cl::desc("Passes Available"));
|
||||
|
||||
cl::opt<bool> NoVerify("disable-verify", cl::Hidden,
|
||||
cl::desc("Do not verify input module"));
|
||||
cl::desc("Do not verify input module"));
|
||||
|
||||
|
||||
// GetFileNameRoot - Helper function to get the basename of a filename.
|
||||
|
Loading…
Reference in New Issue
Block a user