[MLIR][NFC] Eliminate .getBlocks() when not needed

mlir/lib/Dialect/GPU/IR/GPUDialect.cpp

void LaunchOp::build(OpBuilder &builder, OperationState &result,
   Block *body = new Block();
   body->addArguments(
       std::vector<Type>(kNumConfigRegionAttributes, builder.getIndexType()));
   kernelRegion->push_back(body);
 }
 
 KernelDim3 LaunchOp::getBlockIds() {
   assert(!body().empty() && "LaunchOp body must not be empty.");
-  auto args = body().getBlocks().front().getArguments();
+  auto args = body().front().getArguments();
   return KernelDim3{args[0], args[1], args[2]};
 }
 
 KernelDim3 LaunchOp::getThreadIds() {
   assert(!body().empty() && "LaunchOp body must not be empty.");
-  auto args = body().getBlocks().front().getArguments();
+  auto args = body().front().getArguments();
   return KernelDim3{args[3], args[4], args[5]};
 }
 
 KernelDim3 LaunchOp::getGridSize() {
   assert(!body().empty() && "LaunchOp body must not be empty.");
-  auto args = body().getBlocks().front().getArguments();
+  auto args = body().front().getArguments();
   return KernelDim3{args[6], args[7], args[8]};
 }
 
 KernelDim3 LaunchOp::getBlockSize() {
   assert(!body().empty() && "LaunchOp body must not be empty.");
   auto args = body().getBlocks().front().getArguments();
   return KernelDim3{args[9], args[10], args[11]};
 }

mlir/lib/Dialect/LLVMIR/Transforms/LegalizeForExport.cpp

for (int position : llvm::drop_begin(successor.second, 1)) {
       builder.create<LLVM::BrOp>(terminator->getLoc(),
                                  dummyBlock->getArguments(), successor.first);
     }
   }
 }
 
 void mlir::LLVM::ensureDistinctSuccessors(Operation *op) {
   op->walk([](LLVMFuncOp f) {
-    for (auto &bb : f.getBlocks()) {
+    for (auto &bb : f) {
       ::ensureDistinctSuccessors(bb);
     }
   });
 }
 
 namespace {
 struct LegalizeForExportPass
     : public LLVMLegalizeForExportBase<LegalizeForExportPass> {

mlir/lib/ExecutionEngine/JitRunner.cpp

compileAndExecute(Options &options, ModuleOp module, StringRef entryPoint,
 
   return Error::success();
 }
 
 static Error compileAndExecuteVoidFunction(
     Options &options, ModuleOp module, StringRef entryPoint,
     std::function<llvm::Error(llvm::Module *)> transformer) {
   auto mainFunction = module.lookupSymbol<LLVM::LLVMFuncOp>(entryPoint);
-  if (!mainFunction || mainFunction.getBlocks().empty())
+  if (!mainFunction || mainFunction.empty())
     return make_string_error("entry point not found");
   void *empty = nullptr;
   return compileAndExecute(options, module, entryPoint, transformer, &empty);
 }
 
 template <typename Type>
 Error checkCompatibleReturnType(LLVM::LLVMFuncOp mainFunction);
 template <>

mlir/lib/Target/LLVMIR/ModuleTranslation.cpp

 }
 
 /// Sort function blocks topologically.
 static llvm::SetVector<Block *> topologicalSort(LLVMFuncOp f) {
   // For each blocks that has not been visited yet (i.e. that has no
   // predecessors), add it to the list and traverse its successors in DFS
   // preorder.
   llvm::SetVector<Block *> blocks;
-  for (Block &b : f.getBlocks()) {
+  for (Block &b : f) {
     if (blocks.count(&b) == 0)
       topologicalSortImpl(blocks, &b);
   }
   assert(blocks.size() == f.getBlocks().size() && "some blocks are not sorted");
 
   return blocks;
 }
 

mlir/lib/Transforms/LoopInvariantCodeMotion.cpp

if (auto memInterface = dyn_cast<MemoryEffectOpInterface>(op)) {
     // side-effecting.
   } else if (!op->hasTrait<OpTrait::HasRecursiveSideEffects>()) {
     return false;
   }
 
   // Recurse into the regions for this op and check whether the contained ops
   // can be hoisted.
   for (auto &region : op->getRegions()) {
-    for (auto &block : region.getBlocks()) {
+    for (auto &block : region) {
       for (auto &innerOp : block.without_terminator())
         if (!canBeHoisted(&innerOp, definedOutside))
           return false;
     }
   }
   return true;
 }