Commit f798eb21 authored by Nicola Zaghen's avatar Nicola Zaghen
Browse files

Temporarily Revert "[DataLayout] Fix occurrences that size and range of... 

Temporarily Revert "[DataLayout] Fix occurrences that size and range of pointers are assumed to be the same."

This reverts commit 5f620877.

This caused failures in Transforms/PhaseOrdering/scev-custom-dl.ll
const: Assertion `getBitWidth() == CR.getBitWidth() && "ConstantRange types don't agree!"' failed.
parent 9c48c2f9

clang/lib/CodeGen/CGExprScalar.cpp

+2 −2
Original line number Diff line number Diff line
@@ -3264,10 +3264,10 @@ static Value *emitPointerArithmetic(CodeGenFunction &CGF, 
                                                       expr->getRHS()))

    return CGF.Builder.CreateIntToPtr(index, pointer->getType());



  if (width != DL.getIndexTypeSizeInBits(PtrTy)) {

  if (width != DL.getTypeSizeInBits(PtrTy)) {

    // Zero-extend or sign-extend the pointer value according to

    // whether the index is signed or not.

    index = CGF.Builder.CreateIntCast(index, DL.getIndexType(PtrTy), isSigned,

    index = CGF.Builder.CreateIntCast(index, DL.getIntPtrType(PtrTy), isSigned,

                                      "idx.ext");

  }

llvm/include/llvm/Analysis/PtrUseVisitor.h

+2 −2
Original line number Diff line number Diff line
@@ -222,9 +222,9 @@ public: 
    // offsets on this pointer.

    // FIXME: Support a vector of pointers.

    assert(I.getType()->isPointerTy());

    IntegerType *IntIdxTy = cast<IntegerType>(DL.getIndexType(I.getType()));

    IntegerType *IntPtrTy = cast<IntegerType>(DL.getIntPtrType(I.getType()));

    IsOffsetKnown = true;

    Offset = APInt(IntIdxTy->getBitWidth(), 0);

    Offset = APInt(IntPtrTy->getBitWidth(), 0);

    PI.reset();



    // Enqueue the uses of this pointer.

llvm/include/llvm/Analysis/Utils/Local.h

+13 −13
Original line number Diff line number Diff line
@@ -29,15 +29,15 @@ template <typename IRBuilderTy> 
Value *EmitGEPOffset(IRBuilderTy *Builder, const DataLayout &DL, User *GEP,

                     bool NoAssumptions = false) {

  GEPOperator *GEPOp = cast<GEPOperator>(GEP);

  Type *IntIdxTy = DL.getIndexType(GEP->getType());

  Value *Result = Constant::getNullValue(IntIdxTy);

  Type *IntPtrTy = DL.getIntPtrType(GEP->getType());

  Value *Result = Constant::getNullValue(IntPtrTy);



  // If the GEP is inbounds, we know that none of the addressing operations will

  // overflow in a signed sense.

  bool isInBounds = GEPOp->isInBounds() && !NoAssumptions;



  // Build a mask for high order bits.

  unsigned IntPtrWidth = IntIdxTy->getScalarType()->getIntegerBitWidth();

  unsigned IntPtrWidth = IntPtrTy->getScalarType()->getIntegerBitWidth();

  uint64_t PtrSizeMask =

      std::numeric_limits<uint64_t>::max() >> (64 - IntPtrWidth);
@@ -56,17 +56,17 @@ Value *EmitGEPOffset(IRBuilderTy *Builder, const DataLayout &DL, User *GEP, 
        Size = DL.getStructLayout(STy)->getElementOffset(OpValue);



        if (Size)

          Result = Builder->CreateAdd(Result, ConstantInt::get(IntIdxTy, Size),

          Result = Builder->CreateAdd(Result, ConstantInt::get(IntPtrTy, Size),

                                      GEP->getName()+".offs");

        continue;

      }



      // Splat the constant if needed.

      if (IntIdxTy->isVectorTy() && !OpC->getType()->isVectorTy())

        OpC = ConstantVector::getSplat(IntIdxTy->getVectorNumElements(), OpC);

      if (IntPtrTy->isVectorTy() && !OpC->getType()->isVectorTy())

        OpC = ConstantVector::getSplat(IntPtrTy->getVectorNumElements(), OpC);



      Constant *Scale = ConstantInt::get(IntIdxTy, Size);

      Constant *OC = ConstantExpr::getIntegerCast(OpC, IntIdxTy, true /*SExt*/);

      Constant *Scale = ConstantInt::get(IntPtrTy, Size);

      Constant *OC = ConstantExpr::getIntegerCast(OpC, IntPtrTy, true /*SExt*/);

      Scale =

          ConstantExpr::getMul(OC, Scale, false /*NUW*/, isInBounds /*NSW*/);

      // Emit an add instruction.
@@ -75,15 +75,15 @@ Value *EmitGEPOffset(IRBuilderTy *Builder, const DataLayout &DL, User *GEP, 
    }



    // Splat the index if needed.

    if (IntIdxTy->isVectorTy() && !Op->getType()->isVectorTy())

      Op = Builder->CreateVectorSplat(IntIdxTy->getVectorNumElements(), Op);

    if (IntPtrTy->isVectorTy() && !Op->getType()->isVectorTy())

      Op = Builder->CreateVectorSplat(IntPtrTy->getVectorNumElements(), Op);



    // Convert to correct type.

    if (Op->getType() != IntIdxTy)

      Op = Builder->CreateIntCast(Op, IntIdxTy, true, Op->getName()+".c");

    if (Op->getType() != IntPtrTy)

      Op = Builder->CreateIntCast(Op, IntPtrTy, true, Op->getName()+".c");

    if (Size != 1) {

      // We'll let instcombine(mul) convert this to a shl if possible.

      Op = Builder->CreateMul(Op, ConstantInt::get(IntIdxTy, Size),

      Op = Builder->CreateMul(Op, ConstantInt::get(IntPtrTy, Size),

                              GEP->getName() + ".idx", false /*NUW*/,

                              isInBounds /*NSW*/);

    }

llvm/lib/Analysis/ConstantFolding.cpp

+10 −10
Original line number Diff line number Diff line
@@ -766,8 +766,8 @@ Constant *SymbolicallyEvaluateBinop(unsigned Opc, Constant *Op0, Constant *Op1, 
Constant *CastGEPIndices(Type *SrcElemTy, ArrayRef<Constant *> Ops,

                         Type *ResultTy, Optional<unsigned> InRangeIndex,

                         const DataLayout &DL, const TargetLibraryInfo *TLI) {

  Type *IntIdxTy = DL.getIndexType(ResultTy);

  Type *IntIdxScalarTy = IntIdxTy->getScalarType();

  Type *IntPtrTy = DL.getIntPtrType(ResultTy);

  Type *IntPtrScalarTy = IntPtrTy->getScalarType();



  bool Any = false;

  SmallVector<Constant*, 32> NewIdxs;
@@ -775,11 +775,11 @@ Constant *CastGEPIndices(Type *SrcElemTy, ArrayRef<Constant *> Ops, 
    if ((i == 1 ||

         !isa<StructType>(GetElementPtrInst::getIndexedType(

             SrcElemTy, Ops.slice(1, i - 1)))) &&

        Ops[i]->getType()->getScalarType() != IntIdxScalarTy) {

        Ops[i]->getType()->getScalarType() != IntPtrScalarTy) {

      Any = true;

      Type *NewType = Ops[i]->getType()->isVectorTy()

                          ? IntIdxTy

                          : IntIdxScalarTy;

                          ? IntPtrTy

                          : IntPtrTy->getScalarType();

      NewIdxs.push_back(ConstantExpr::getCast(CastInst::getCastOpcode(Ops[i],

                                                                      true,

                                                                      NewType,
@@ -839,7 +839,7 @@ Constant *SymbolicallyEvaluateGEP(const GEPOperator *GEP, 
  if (!Ptr->getType()->isPointerTy())

    return nullptr;



  Type *IntIdxTy = DL.getIndexType(Ptr->getType());

  Type *IntPtrTy = DL.getIntPtrType(Ptr->getType());



  // If this is a constant expr gep that is effectively computing an

  // "offsetof", fold it into 'cast int Size to T*' instead of 'gep 0, 0, 12'
@@ -850,7 +850,7 @@ Constant *SymbolicallyEvaluateGEP(const GEPOperator *GEP, 
        // "inttoptr (sub (ptrtoint Ptr), V)"

        if (Ops.size() == 2 && ResElemTy->isIntegerTy(8)) {

          auto *CE = dyn_cast<ConstantExpr>(Ops[1]);

          assert((!CE || CE->getType() == IntIdxTy) &&

          assert((!CE || CE->getType() == IntPtrTy) &&

                 "CastGEPIndices didn't canonicalize index types!");

          if (CE && CE->getOpcode() == Instruction::Sub &&

              CE->getOperand(0)->isNullValue()) {
@@ -865,7 +865,7 @@ Constant *SymbolicallyEvaluateGEP(const GEPOperator *GEP, 
        return nullptr;

      }



  unsigned BitWidth = DL.getTypeSizeInBits(IntIdxTy);

  unsigned BitWidth = DL.getTypeSizeInBits(IntPtrTy);

  APInt Offset =

      APInt(BitWidth,

            DL.getIndexedOffsetInType(
@@ -945,7 +945,7 @@ Constant *SymbolicallyEvaluateGEP(const GEPOperator *GEP, 
        // The element size is 0. This may be [0 x Ty]*, so just use a zero

        // index for this level and proceed to the next level to see if it can

        // accommodate the offset.

        NewIdxs.push_back(ConstantInt::get(IntIdxTy, 0));

        NewIdxs.push_back(ConstantInt::get(IntPtrTy, 0));

      } else {

        // The element size is non-zero divide the offset by the element

        // size (rounding down), to compute the index at this level.
@@ -954,7 +954,7 @@ Constant *SymbolicallyEvaluateGEP(const GEPOperator *GEP, 
        if (Overflow)

          break;

        Offset -= NewIdx * ElemSize;

        NewIdxs.push_back(ConstantInt::get(IntIdxTy, NewIdx));

        NewIdxs.push_back(ConstantInt::get(IntPtrTy, NewIdx));

      }

    } else {

      auto *STy = cast<StructType>(Ty);

llvm/lib/Analysis/InlineCost.cpp

+2 −2
Original line number Diff line number Diff line
@@ -1678,8 +1678,8 @@ ConstantInt *CallAnalyzer::stripAndComputeInBoundsConstantOffsets(Value *&V) { 
    assert(V->getType()->isPointerTy() && "Unexpected operand type!");

  } while (Visited.insert(V).second);



  Type *IdxPtrTy = DL.getIndexType(V->getType());

  return cast<ConstantInt>(ConstantInt::get(IdxPtrTy, Offset));

  Type *IntPtrTy = DL.getIntPtrType(V->getContext(), AS);

  return cast<ConstantInt>(ConstantInt::get(IntPtrTy, Offset));

}



/// Find dead blocks due to deleted CFG edges during inlining.