diff --git a/compiler/src/iree/compiler/Codegen/Common/DecomposePackUnPackOps.cpp b/compiler/src/iree/compiler/Codegen/Common/DecomposePackUnPackOps.cpp
index 771b73bf9425b..898791cf14bb4 100644
--- a/compiler/src/iree/compiler/Codegen/Common/DecomposePackUnPackOps.cpp
+++ b/compiler/src/iree/compiler/Codegen/Common/DecomposePackUnPackOps.cpp
@@ -176,7 +176,7 @@ void DecomposePackUnPackOpsPass::runOnOperation() {
     IRRewriter rewriter(ctx);
     auto packOptions = scf::SCFTileAndFuseOptions().setTilingOptions(
         scf::SCFTilingOptions().setTileSizeComputationFunction(
-            [](OpBuilder &builder, Operation *op) -> SmallVector<Value> {
+            [](OpBuilder &builder, Operation *op) -> SmallVector<OpFoldResult> {
               auto packOp = cast<tensor::PackOp>(op);
 
               // Do nothing if any of inner tile sizes is dynamic.
@@ -187,9 +187,8 @@ void DecomposePackUnPackOpsPass::runOnOperation() {
               }
 
               int inputRank = packOp.getSourceRank();
-              SmallVector<Value> tileSizes(
-                  inputRank,
-                  builder.create<arith::ConstantIndexOp>(packOp.getLoc(), 1));
+              SmallVector<OpFoldResult> tileSizes(inputRank,
+                                                  builder.getIndexAttr(1));
               return tileSizes;
             }));
     funcOp->walk([&](tensor::PackOp op) {
@@ -204,18 +203,15 @@ void DecomposePackUnPackOpsPass::runOnOperation() {
     auto unpackTilingOptions =
         scf::SCFTilingOptions().setTileSizeComputationFunction(
             [](OpBuilder &builder, Operation *op) {
-              Location loc = op->getLoc();
               auto unpackOp = cast<tensor::UnPackOp>(op);
               int numLoops = unpackOp.getDestRank();
               auto dimAndTileMapping = unpackOp.getDimAndTileMapping();
-              SmallVector<Value> tileSizes;
+              SmallVector<OpFoldResult> tileSizes;
               for (int i = 0; i < numLoops; ++i) {
                 if (dimAndTileMapping.count(i)) {
-                  tileSizes.push_back(getValueOrCreateConstantIndexOp(
-                      builder, loc, dimAndTileMapping[i]));
+                  tileSizes.push_back(dimAndTileMapping[i]);
                 } else {
-                  tileSizes.push_back(
-                      builder.create<arith::ConstantIndexOp>(loc, 1));
+                  tileSizes.push_back(builder.getIndexAttr(1));
                 }
               }
               return tileSizes;
diff --git a/compiler/src/iree/compiler/Codegen/Common/GPU/GPUTensorTile.cpp b/compiler/src/iree/compiler/Codegen/Common/GPU/GPUTensorTile.cpp
index 5e5cc376f4b15..c2664ff065441 100644
--- a/compiler/src/iree/compiler/Codegen/Common/GPU/GPUTensorTile.cpp
+++ b/compiler/src/iree/compiler/Codegen/Common/GPU/GPUTensorTile.cpp
@@ -77,8 +77,10 @@ class TileConsumerAndFuseInputProducer final
     }
 
     // Tile the current op and fuse its immediate input operands.
+    SmallVector<OpFoldResult> tileSizesOfr =
+        getAsIndexOpFoldResult(rewriter.getContext(), tileSizes);
     FailureOr<scf::SCFTilingResult> tilingResult =
-        tileConsumerAndFuseInputProducer(rewriter, op, tileSizes);
+        tileConsumerAndFuseInputProducer(rewriter, op, tileSizesOfr);
     if (failed(tilingResult)) {
       return rewriter.notifyMatchFailure(op, "failed to tile consumer");
     }
@@ -94,7 +96,7 @@ class TileConsumerAndFuseInputProducer final
   FailureOr<scf::SCFTilingResult>
   tileConsumerAndFuseInputProducer(PatternRewriter &rewriter,
                                    TilingInterface consumer,
-                                   ArrayRef<int64_t> tileSizes) const {
+                                   ArrayRef<OpFoldResult> tileSizes) const {
     // First tile the current op as the consumer op.
     auto tilingOptions = scf::SCFTilingOptions().setTileSizes(tileSizes);
     FailureOr<scf::SCFTilingResult> tilingResult =
@@ -275,7 +277,8 @@ static LogicalResult tileAndUnrollConv(func::FuncOp funcOp) {
   for (linalg::ConvolutionOpInterface convOp : convOps) {
     auto consumerOp = cast<linalg::LinalgOp>(*convOp);
     IRRewriter rewriter(funcOp.getContext());
-    SmallVector<int64_t> tileSizes = getTileSizes(consumerOp, 1);
+    SmallVector<OpFoldResult> tileSizes = getAsIndexOpFoldResult(
+        funcOp.getContext(), getTileSizes(consumerOp, 1));
     if (tileSizes.empty())
       return success();
 
diff --git a/compiler/src/iree/compiler/Codegen/LLVMCPU/LLVMCPUSplitReduction.cpp b/compiler/src/iree/compiler/Codegen/LLVMCPU/LLVMCPUSplitReduction.cpp
index 7a347875de5e2..23fffd2627d87 100644
--- a/compiler/src/iree/compiler/Codegen/LLVMCPU/LLVMCPUSplitReduction.cpp
+++ b/compiler/src/iree/compiler/Codegen/LLVMCPU/LLVMCPUSplitReduction.cpp
@@ -119,8 +119,9 @@ LogicalResult splitReductionImpl(Operation *op, int64_t size,
   auto numLoops = linalgOp.getNumLoops();
 
   // 1) Tile to extract a single vector-length array.
-  SmallVector<int64_t> tileSizesSVFirst(numLoops, 1);
-  tileSizesSVFirst[numLoops - 1] = 0;
+  SmallVector<OpFoldResult> tileSizesSVFirst(numLoops,
+                                             rewriter.getIndexAttr(1));
+  tileSizesSVFirst[numLoops - 1] = rewriter.getIndexAttr(0);
   auto options = scf::SCFTilingOptions().setTileSizes(tileSizesSVFirst);
   FailureOr<scf::SCFTilingResult> tileResFirst = scf::tileUsingSCFForOp(
       rewriter, cast<TilingInterface>(linalgOp.getOperation()), options);
@@ -142,10 +143,11 @@ LogicalResult splitReductionImpl(Operation *op, int64_t size,
   // 3) Tile the first op generated by splitReduction with tile size of 1,
   // to essentially create a reduction loop. Note that
   // splitRes->splitLinalgOp.getNumLoops() = numLoops + 1.
-  SmallVector<int64_t> tileSizesSV(splitRes->splitLinalgOp.getNumLoops(), 0);
+  SmallVector<OpFoldResult> tileSizesSV(splitRes->splitLinalgOp.getNumLoops(),
+                                        rewriter.getIndexAttr(0));
   // The reduction happens only in the penultimate dimension, which we now
   // tile.
-  tileSizesSV[numLoops - 1] = 1;
+  tileSizesSV[numLoops - 1] = rewriter.getIndexAttr(1);
   options = scf::SCFTilingOptions().setTileSizes(tileSizesSV);
   FailureOr<scf::SCFTilingResult> tileRes = scf::tileUsingSCFForOp(
       rewriter, cast<TilingInterface>(splitRes->splitLinalgOp.getOperation()),
diff --git a/compiler/src/iree/compiler/Codegen/LLVMCPU/LLVMCPUTile.cpp b/compiler/src/iree/compiler/Codegen/LLVMCPU/LLVMCPUTile.cpp
index e8a0cccc8347e..e9671f10cc12d 100644
--- a/compiler/src/iree/compiler/Codegen/LLVMCPU/LLVMCPUTile.cpp
+++ b/compiler/src/iree/compiler/Codegen/LLVMCPU/LLVMCPUTile.cpp
@@ -29,17 +29,15 @@ namespace {
 /// Builds a proper tile sizes vector for the op.
 /// scf::tileUsingSCFForOp expects the num of tile sizes = num of loops. This
 /// method returns a proper tile sizes vector for each op during tiling.
-static SmallVector<Value> buildTileSizesForOp(OpBuilder &b, Operation *op,
-                                              ArrayRef<int64_t> tileSizes) {
+static SmallVector<OpFoldResult>
+buildTileSizesForOp(OpBuilder &b, Operation *op, ArrayRef<int64_t> tileSizes) {
   auto tilingOp = cast<TilingInterface>(op);
 
   SmallVector<int64_t> newTileSizes(tileSizes);
   newTileSizes.resize(tilingOp.getLoopIteratorTypes().size(), /*default=*/0);
 
   OpBuilder::InsertionGuard guard(b);
-  return llvm::map_to_vector(newTileSizes, [&](int64_t size) -> Value {
-    return b.create<arith::ConstantIndexOp>(tilingOp->getLoc(), size);
-  });
+  return getAsIndexOpFoldResult(b.getContext(), newTileSizes);
 }
 
 /// This pass tiles all the TilingInterface operations. The `tilingLevel` must
diff --git a/compiler/src/iree/compiler/Codegen/LLVMCPU/LLVMCPUTileAndFuse.cpp b/compiler/src/iree/compiler/Codegen/LLVMCPU/LLVMCPUTileAndFuse.cpp
index ce8b3718de232..31f3faf45b196 100644
--- a/compiler/src/iree/compiler/Codegen/LLVMCPU/LLVMCPUTileAndFuse.cpp
+++ b/compiler/src/iree/compiler/Codegen/LLVMCPU/LLVMCPUTileAndFuse.cpp
@@ -245,6 +245,7 @@ void LLVMCPUTileAndFusePass::runOnOperation() {
     tileSizes = maybeLoweringConfig.value().getTileSizeVals(tilingLevel);
   }
 
+  IRRewriter rewriter(context);
   int numLoops = consumerOp.getLoopIteratorTypes().size();
   if (numLoops > tileSizes.size()) {
     tileSizes.append(numLoops - tileSizes.size(), 0);
@@ -256,8 +257,9 @@ void LLVMCPUTileAndFusePass::runOnOperation() {
     return;
   }
 
-  auto options = scf::SCFTilingOptions().setTileSizes(tileSizes);
-  IRRewriter rewriter(context);
+  SmallVector<OpFoldResult> tileSizesOfr =
+      getAsIndexOpFoldResult(rewriter.getContext(), tileSizes);
+  auto options = scf::SCFTilingOptions().setTileSizes(tileSizesOfr);
   if (failed(applyTileAndFuse(rewriter, consumerOp, options))) {
     LLVM_DEBUG(llvm::dbgs() << "----- tile and fuse failed -----\n");
     return signalPassFailure();
diff --git a/compiler/src/iree/compiler/Codegen/SPIRV/SPIRVTile.cpp b/compiler/src/iree/compiler/Codegen/SPIRV/SPIRVTile.cpp
index 97eac04df9dbd..13a7290f7b028 100644
--- a/compiler/src/iree/compiler/Codegen/SPIRV/SPIRVTile.cpp
+++ b/compiler/src/iree/compiler/Codegen/SPIRV/SPIRVTile.cpp
@@ -115,11 +115,13 @@ static LogicalResult tileAndDistributeToThreads(linalg::LinalgOp consumerOp,
                                                 ArrayRef<int64_t> tileSizes) {
   MLIRContext *context = consumerOp.getContext();
   IRRewriter rewriter(context);
+  SmallVector<OpFoldResult> tileSizesOfr =
+      getAsIndexOpFoldResult(context, tileSizes);
   FailureOr<scf::SCFTileAndFuseResult> tileAndFuseResult =
       scf::tileConsumerAndFuseProducerGreedilyUsingSCFForOp(
           rewriter, cast<TilingInterface>(consumerOp.getOperation()),
           scf::SCFTileAndFuseOptions().setTilingOptions(
-              scf::SCFTilingOptions().setTileSizes(tileSizes)));
+              scf::SCFTilingOptions().setTileSizes(tileSizesOfr)));
 
   if (failed(tileAndFuseResult)) {
     return consumerOp.emitOpError("failed tiling and fusing producers");
@@ -240,7 +242,7 @@ static void concretizePadShape(func::FuncOp funcOp) {
 /// Tiles one of the convolution output window dimensions with size 1 to prepare
 /// for downsizing 2-D convolution ops into 1-D ones.
 static LogicalResult tileAndUnrollConvWindow(func::FuncOp funcOp,
-                                             ArrayRef<int64_t> tileSizes) {
+                                             ArrayRef<OpFoldResult> tileSizes) {
   SmallVector<linalg::ConvolutionOpInterface, 1> convOps;
   funcOp.walk([&convOps](linalg::ConvolutionOpInterface convOp) {
     convOps.push_back(convOp);
@@ -344,7 +346,8 @@ class SPIRVTilePass final : public SPIRVTileBase<SPIRVTilePass> {
 
     fusePadIntoConsumer(funcOp);
 
-    SmallVector<int64_t> windowTileSizes = loweringConfig->getTileSizeVals(3);
+    SmallVector<OpFoldResult> windowTileSizes =
+        getAsIndexOpFoldResult(context, loweringConfig->getTileSizeVals(3));
     if (failed(tileAndUnrollConvWindow(funcOp, windowTileSizes))) {
       return signalPassFailure();
     }