6502/llvm-6502
1
0
Fork 0
mirror of https://github.com/c64scene-ar/llvm-6502.git synced 2025-02-27 02:31:09 +00:00
Code Issues Projects Releases Wiki Activity

Various comment fixes.

Browse Source 
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@72376 91177308-0d34-0410-b5e6-96231b3b80d8
This commit is contained in:
Dan Gohman 2009-05-24 23:45:28 +00:00
parent d594e6f034
commit 6c0866ca83
2 changed files with 16 additions and 11 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
include/llvm/Analysis/ScalarEvolution.h
View File

@ -35,8 +35,8 @@ namespace llvm {
class ScalarEvolution;
class TargetData;
/// SCEV - This class represent an analyzed expression in the program. These
/// are reference counted opaque objects that the client is not allowed to
/// SCEV - This class represents an analyzed expression in the program. These
/// are reference-counted opaque objects that the client is not allowed to
/// do much with directly.
///
class SCEV {

23
lib/Analysis/ScalarEvolution.cpp
View File

@ -596,7 +596,7 @@ static void GroupByComplexity(std::vector<SCEVHandle> &Ops,
//===----------------------------------------------------------------------===//
/// BinomialCoefficient - Compute BC(It, K). The result has width W.
// Assume, K > 0.
/// Assume, K > 0.
static SCEVHandle BinomialCoefficient(SCEVHandle It, unsigned K,
ScalarEvolution &SE,
const Type* ResultTy) {
@ -933,7 +933,8 @@ SCEVHandle ScalarEvolution::getSignExtendExpr(const SCEVHandle &Op,
return Result;
}
// get - Get a canonical add expression, or something simpler if possible.
/// getAddExpr - Get a canonical add expression, or something simpler if
/// possible.
SCEVHandle ScalarEvolution::getAddExpr(std::vector<SCEVHandle> &Ops) {
assert(!Ops.empty() && "Cannot get empty add!");
if (Ops.size() == 1) return Ops[0];
@ -1225,6 +1226,8 @@ SCEVHandle ScalarEvolution::getAddExpr(std::vector<SCEVHandle> &Ops) {
}
/// getMulExpr - Get a canonical multiply expression, or something simpler if
/// possible.
SCEVHandle ScalarEvolution::getMulExpr(std::vector<SCEVHandle> &Ops) {
assert(!Ops.empty() && "Cannot get empty mul!");
#ifndef NDEBUG
@ -1388,6 +1391,8 @@ SCEVHandle ScalarEvolution::getMulExpr(std::vector<SCEVHandle> &Ops) {
return Result;
}
/// getUDivExpr - Get a canonical multiply expression, or something simpler if
/// possible.
SCEVHandle ScalarEvolution::getUDivExpr(const SCEVHandle &LHS,
const SCEVHandle &RHS) {
assert(getEffectiveSCEVType(LHS->getType()) ==
@ -1476,8 +1481,8 @@ SCEVHandle ScalarEvolution::getUDivExpr(const SCEVHandle &LHS,
}
/// SCEVAddRecExpr::get - Get a add recurrence expression for the
/// specified loop. Simplify the expression as much as possible.
/// getAddRecExpr - Get an add recurrence expression for the specified loop.
/// Simplify the expression as much as possible.
SCEVHandle ScalarEvolution::getAddRecExpr(const SCEVHandle &Start,
const SCEVHandle &Step, const Loop *L) {
std::vector<SCEVHandle> Operands;
@ -1493,8 +1498,8 @@ SCEVHandle ScalarEvolution::getAddRecExpr(const SCEVHandle &Start,
return getAddRecExpr(Operands, L);
}
/// SCEVAddRecExpr::get - Get a add recurrence expression for the
/// specified loop. Simplify the expression as much as possible.
/// getAddRecExpr - Get an add recurrence expression for the specified loop.
/// Simplify the expression as much as possible.
SCEVHandle ScalarEvolution::getAddRecExpr(std::vector<SCEVHandle> &Operands,
const Loop *L) {
if (Operands.size() == 1) return Operands[0];
@ -3201,7 +3206,7 @@ SolveQuadraticEquation(const SCEVAddRecExpr *AddRec, ScalarEvolution &SE) {
}
/// HowFarToZero - Return the number of times a backedge comparing the specified
/// value to zero will execute. If not computable, return UnknownValue
/// value to zero will execute. If not computable, return UnknownValue.
SCEVHandle ScalarEvolution::HowFarToZero(const SCEV *V, const Loop *L) {
// If the value is a constant
if (const SCEVConstant *C = dyn_cast<SCEVConstant>(V)) {
@ -3506,8 +3511,8 @@ HowManyLessThans(const SCEV *LHS, const SCEV *RHS,
// If we know that the condition is true in order to enter the loop,
// then we know that it will run exactly (m-n)/s times. Otherwise, we
// only know if will execute (max(m,n)-n)/s times. In both cases, the
// division must round up.
// only know that it will execute (max(m,n)-n)/s times. In both cases,
// the division must round up.
SCEVHandle End = RHS;
if (!isLoopGuardedByCond(L,
isSigned ? ICmpInst::ICMP_SLT : ICmpInst::ICMP_ULT,