6502/llvm-6502
1
0
Fork 0
mirror of https://github.com/c64scene-ar/llvm-6502.git synced 2024-08-22 10:29:35 +00:00
Code Issues Projects Releases Wiki Activity

don't repeat function names in comments; NFC

Browse Source 
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@235531 91177308-0d34-0410-b5e6-96231b3b80d8
This commit is contained in:
Sanjay Patel 2015-04-22 18:04:46 +00:00
parent 1d50fea817
commit f3bad3fece
1 changed files with 31 additions and 38 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

69
lib/Transforms/Scalar/Reassociate.cpp
View File

@ -59,7 +59,7 @@ namespace {
}
#ifndef NDEBUG
/// PrintOps - Print out the expression identified in the Ops list.
/// Print out the expression identified in the Ops list.
///
static void PrintOps(Instruction *I, const SmallVectorImpl<ValueEntry> &Ops) {
Module *M = I->getParent()->getParent()->getParent();
@ -233,8 +233,8 @@ INITIALIZE_PASS(Reassociate, "reassociate",
// Public interface to the Reassociate pass
FunctionPass *llvm::createReassociatePass() { return new Reassociate(); }
/// isReassociableOp - Return true if V is an instruction of the specified
/// opcode and if it only has one use.
/// Return true if V is an instruction of the specified opcode and if it
/// only has one use.
static BinaryOperator *isReassociableOp(Value *V, unsigned Opcode) {
if (V->hasOneUse() && isa<Instruction>(V) &&
cast<Instruction>(V)->getOpcode() == Opcode &&
@ -382,8 +382,7 @@ static BinaryOperator *CreateNeg(Value *S1, const Twine &Name,
}
}
/// LowerNegateToMultiply - Replace 0-X with X*-1.
///
/// Replace 0-X with X*-1.
static BinaryOperator *LowerNegateToMultiply(Instruction *Neg) {
Type *Ty = Neg->getType();
Constant *NegOne = Ty->isIntOrIntVectorTy() ?
@ -397,8 +396,8 @@ static BinaryOperator *LowerNegateToMultiply(Instruction *Neg) {
return Res;
}
/// CarmichaelShift - Returns k such that lambda(2^Bitwidth) = 2^k, where lambda
/// is the Carmichael function. This means that x^(2^k) === 1 mod 2^Bitwidth for
/// Returns k such that lambda(2^Bitwidth) = 2^k, where lambda is the Carmichael
/// function. This means that x^(2^k) === 1 mod 2^Bitwidth for
/// every odd x, i.e. x^(2^k) = 1 for every odd x in Bitwidth-bit arithmetic.
/// Note that 0 <= k < Bitwidth, and if Bitwidth > 3 then x^(2^k) = 0 for every
/// even x in Bitwidth-bit arithmetic.
@ -408,7 +407,7 @@ static unsigned CarmichaelShift(unsigned Bitwidth) {
return Bitwidth - 2;
}
/// IncorporateWeight - Add the extra weight 'RHS' to the existing weight 'LHS',
/// Add the extra weight 'RHS' to the existing weight 'LHS',
/// reducing the combined weight using any special properties of the operation.
/// The existing weight LHS represents the computation X op X op ... op X where
/// X occurs LHS times. The combined weight represents X op X op ... op X with
@ -490,7 +489,7 @@ static void IncorporateWeight(APInt &LHS, const APInt &RHS, unsigned Opcode) {
typedef std::pair<Value*, APInt> RepeatedValue;
/// LinearizeExprTree - Given an associative binary expression, return the leaf
/// Given an associative binary expression, return the leaf
/// nodes in Ops along with their weights (how many times the leaf occurs). The
/// original expression is the same as
/// (Ops[0].first op Ops[0].first op ... Ops[0].first) <- Ops[0].second times
@ -740,8 +739,8 @@ static bool LinearizeExprTree(BinaryOperator *I,
return Changed;
}
// RewriteExprTree - Now that the operands for this expression tree are
// linearized and optimized, emit them in-order.
/// Now that the operands for this expression tree are
/// linearized and optimized, emit them in-order.
void Reassociate::RewriteExprTree(BinaryOperator *I,
SmallVectorImpl<ValueEntry> &Ops) {
assert(Ops.size() > 1 && "Single values should be used directly!");
@ -910,7 +909,7 @@ void Reassociate::RewriteExprTree(BinaryOperator *I,
RedoInsts.insert(NodesToRewrite[i]);
}
/// NegateValue - Insert instructions before the instruction pointed to by BI,
/// Insert instructions before the instruction pointed to by BI,
/// that computes the negative version of the value specified. The negative
/// version of the value is returned, and BI is left pointing at the instruction
/// that should be processed next by the reassociation pass.
@ -985,8 +984,7 @@ static Value *NegateValue(Value *V, Instruction *BI) {
return CreateNeg(V, V->getName() + ".neg", BI, BI);
}
/// ShouldBreakUpSubtract - Return true if we should break up this subtract of
/// X-Y into (X + -Y).
/// Return true if we should break up this subtract of X-Y into (X + -Y).
static bool ShouldBreakUpSubtract(Instruction *Sub) {
// If this is a negation, we can't split it up!
if (BinaryOperator::isNeg(Sub) || BinaryOperator::isFNeg(Sub))
@ -1015,9 +1013,8 @@ static bool ShouldBreakUpSubtract(Instruction *Sub) {
return false;
}
/// BreakUpSubtract - If we have (X-Y), and if either X is an add, or if this is
/// only used by an add, transform this into (X+(0-Y)) to promote better
/// reassociation.
/// If we have (X-Y), and if either X is an add, or if this is only used by an
/// add, transform this into (X+(0-Y)) to promote better reassociation.
static BinaryOperator *BreakUpSubtract(Instruction *Sub) {
// Convert a subtract into an add and a neg instruction. This allows sub
// instructions to be commuted with other add instructions.
@ -1039,9 +1036,8 @@ static BinaryOperator *BreakUpSubtract(Instruction *Sub) {
return New;
}
/// ConvertShiftToMul - If this is a shift of a reassociable multiply or is used
/// by one, change this into a multiply by a constant to assist with further
/// reassociation.
/// If this is a shift of a reassociable multiply or is used by one, change
/// this into a multiply by a constant to assist with further reassociation.
static BinaryOperator *ConvertShiftToMul(Instruction *Shl) {
Constant *MulCst = ConstantInt::get(Shl->getType(), 1);
MulCst = ConstantExpr::getShl(MulCst, cast<Constant>(Shl->getOperand(1)));
@ -1066,10 +1062,9 @@ static BinaryOperator *ConvertShiftToMul(Instruction *Shl) {
return Mul;
}
/// FindInOperandList - Scan backwards and forwards among values with the same
/// rank as element i to see if X exists. If X does not exist, return i. This
/// is useful when scanning for 'x' when we see '-x' because they both get the
/// same rank.
/// Scan backwards and forwards among values with the same rank as element i
/// to see if X exists. If X does not exist, return i. This is useful when
/// scanning for 'x' when we see '-x' because they both get the same rank.
static unsigned FindInOperandList(SmallVectorImpl<ValueEntry> &Ops, unsigned i,
Value *X) {
unsigned XRank = Ops[i].Rank;
@ -1094,7 +1089,7 @@ static unsigned FindInOperandList(SmallVectorImpl<ValueEntry> &Ops, unsigned i,
return i;
}
/// EmitAddTreeOfValues - Emit a tree of add instructions, summing Ops together
/// Emit a tree of add instructions, summing Ops together
/// and returning the result. Insert the tree before I.
static Value *EmitAddTreeOfValues(Instruction *I,
SmallVectorImpl<WeakVH> &Ops){
@ -1106,8 +1101,8 @@ static Value *EmitAddTreeOfValues(Instruction *I,
return CreateAdd(V2, V1, "tmp", I, I);
}
/// RemoveFactorFromExpression - If V is an expression tree that is a
/// multiplication sequence, and if this sequence contains a multiply by Factor,
/// If V is an expression tree that is a multiplication sequence,
/// and if this sequence contains a multiply by Factor,
/// remove Factor from the tree and return the new tree.
Value *Reassociate::RemoveFactorFromExpression(Value *V, Value *Factor) {
BinaryOperator *BO = isReassociableOp(V, Instruction::Mul, Instruction::FMul);
@ -1179,8 +1174,8 @@ Value *Reassociate::RemoveFactorFromExpression(Value *V, Value *Factor) {
return V;
}
/// FindSingleUseMultiplyFactors - If V is a single-use multiply, recursively
/// add its operands as factors, otherwise add V to the list of factors.
/// If V is a single-use multiply, recursively add its operands as factors,
/// otherwise add V to the list of factors.
///
/// Ops is the top-level list of add operands we're trying to factor.
static void FindSingleUseMultiplyFactors(Value *V,
@ -1197,10 +1192,9 @@ static void FindSingleUseMultiplyFactors(Value *V,
FindSingleUseMultiplyFactors(BO->getOperand(0), Factors, Ops);
}
/// OptimizeAndOrXor - Optimize a series of operands to an 'and', 'or', or 'xor'
/// instruction. This optimizes based on identities. If it can be reduced to
/// a single Value, it is returned, otherwise the Ops list is mutated as
/// necessary.
/// Optimize a series of operands to an 'and', 'or', or 'xor' instruction.
/// This optimizes based on identities. If it can be reduced to a single Value,
/// it is returned, otherwise the Ops list is mutated as necessary.
static Value *OptimizeAndOrXor(unsigned Opcode,
SmallVectorImpl<ValueEntry> &Ops) {
// Scan the operand lists looking for X and ~X pairs, along with X,X pairs.
@ -1490,7 +1484,7 @@ Value *Reassociate::OptimizeXor(Instruction *I,
return nullptr;
}
/// OptimizeAdd - Optimize a series of operands to an 'add' instruction. This
/// Optimize a series of operands to an 'add' instruction. This
/// optimizes based on identities. If it can be reduced to a single Value, it
/// is returned, otherwise the Ops list is mutated as necessary.
Value *Reassociate::OptimizeAdd(Instruction *I,
@ -1943,8 +1937,7 @@ Value *Reassociate::OptimizeExpression(BinaryOperator *I,
return nullptr;
}
/// EraseInst - Zap the given instruction, adding interesting operands to the
/// work list.
/// Zap the given instruction, adding interesting operands to the work list.
void Reassociate::EraseInst(Instruction *I) {
assert(isInstructionTriviallyDead(I) && "Trivially dead instructions only!");
SmallVector<Value*, 8> Ops(I->op_begin(), I->op_end());
@ -2058,7 +2051,7 @@ Instruction *Reassociate::canonicalizeNegConstExpr(Instruction *I) {
return NI;
}
/// OptimizeInst - Inspect and optimize the given instruction. Note that erasing
/// Inspect and optimize the given instruction. Note that erasing
/// instructions is not allowed.
void Reassociate::OptimizeInst(Instruction *I) {
// Only consider operations that we understand.
@ -2191,7 +2184,7 @@ void Reassociate::ReassociateExpression(BinaryOperator *I) {
// the vector.
std::stable_sort(Ops.begin(), Ops.end());
// OptimizeExpression - Now that we have the expression tree in a convenient
// Now that we have the expression tree in a convenient
// sorted form, optimize it globally if possible.
if (Value *V = OptimizeExpression(I, Ops)) {
if (V == I)