6502/llvm-6502
1
0
Fork 0
mirror of https://github.com/c64scene-ar/llvm-6502.git synced 2025-04-03 18:32:50 +00:00
Code Issues Projects Releases Wiki Activity

1. Fix bug test/Regression/Other/2002-03-20-LevelRaiseBadCodegen.ll

Browse Source 
2. Allow negative scales in ConvertableToGEP, so that this loop from
   alloc_tree in the Olden health benchmark is correctly raised:

       for (i = 3; i >= 0; i--)
         fval[i] = alloc_tree(level - 1, label*4 + i + 1, new);

   Stepping through the array backwards caused a negative scale.


git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@1922 91177308-0d34-0410-b5e6-96231b3b80d8
This commit is contained in:
Chris Lattner 2002-03-21 03:04:38 +00:00
parent ebcd28eb15
commit 99fb91cc2f
1 changed files with 21 additions and 15 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

36
lib/Transforms/TransformInternals.cpp
View File

@ -141,7 +141,12 @@ const Type *ConvertableToGEP(const Type *Ty, Value *OffsetVal,
analysis::ExprType Expr = analysis::ClassifyExpression(OffsetVal);
// Get the offset and scale now...
unsigned Offset = 0, Scale = Expr.Var != 0;
// A scale of zero with Expr.Var != 0 means a scale of 1.
//
// TODO: Handle negative offsets for C code like this:
// for (unsigned i = 12; i < 14; ++i) x[j*i-12] = ...
unsigned Offset = 0;
int Scale = 0;
// Get the offset value if it exists...
if (Expr.Offset) {
@ -151,13 +156,9 @@ const Type *ConvertableToGEP(const Type *Ty, Value *OffsetVal,
}
// Get the scale value if it exists...
if (Expr.Scale) {
int Val = getConstantValue(Expr.Scale);
if (Val < 0) return false; // Don't mess with negative scales
Scale = (unsigned)Val;
if (Scale == 1) Scale = 0; // No interesting scale if *1
}
if (Expr.Scale) Scale = getConstantValue(Expr.Scale);
if (Expr.Var && Scale == 0) Scale = 1; // Scale != 0 if Expr.Var != 0
// Loop over the Scale and Offset values, filling in the Indices vector for
// our final getelementptr instruction.
//
@ -170,21 +171,24 @@ const Type *ConvertableToGEP(const Type *Ty, Value *OffsetVal,
if (const StructType *StructTy = dyn_cast<StructType>(CompTy)) {
unsigned ActualOffset = Offset;
NextTy = getStructOffsetType(StructTy, ActualOffset, Indices);
if (StructTy == NextTy && ActualOffset == 0) return 0; // No progress. :(
if (StructTy == NextTy && ActualOffset == 0)
return 0; // No progress. :(
Offset -= ActualOffset;
} else {
const Type *ElTy = cast<SequentialType>(CompTy)->getElementType();
if (!ElTy->isSized()) return 0; // Type is unreasonable... escape!
if (!ElTy->isSized())
return 0; // Type is unreasonable... escape!
unsigned ElSize = TD.getTypeSize(ElTy);
int ElSizeS = (int)ElSize;
// See if the user is indexing into a different cell of this array...
if (Scale && Scale >= ElSize) {
if (Scale && (Scale >= ElSizeS || -Scale >= ElSizeS)) {
// A scale n*ElSize might occur if we are not stepping through
// array by one. In this case, we will have to insert math to munge
// the index.
//
unsigned ScaleAmt = Scale/ElSize;
if (Scale-ScaleAmt*ElSize)
int ScaleAmt = Scale/ElSizeS;
if (Scale-ScaleAmt*ElSizeS)
return 0; // Didn't scale by a multiple of element size, bail out
Scale = 0; // Scale is consumed
@ -203,9 +207,10 @@ const Type *ConvertableToGEP(const Type *Ty, Value *OffsetVal,
if (ScaleAmt && ScaleAmt != 1) {
// If we have to scale up our index, do so now
Value *ScaleAmtVal = ConstantUInt::get(Type::UIntTy, ScaleAmt);
Value *ScaleAmtVal = ConstantUInt::get(Type::UIntTy,
(unsigned)ScaleAmt);
Instruction *Scaler = BinaryOperator::create(Instruction::Mul,
Expr.Var,ScaleAmtVal);
Expr.Var, ScaleAmtVal);
if (Expr.Var->hasName())
Scaler->setName(Expr.Var->getName()+"-scale");
@ -225,6 +230,7 @@ const Type *ConvertableToGEP(const Type *Ty, Value *OffsetVal,
}
Indices.push_back(Expr.Var);
Expr.Var = 0;
} else if (Offset >= ElSize) {
// Calculate the index that we are entering into the array cell with
unsigned Index = Offset/ElSize;