Address review feedback

Author: andykaylor

clang/lib/CIR/CodeGen/CIRGenBuilder.h

@@ -289,7 +289,7 @@ class CIRGenBuilderTy : public cir::CIRBaseBuilderTy {
   }
   cir::ConstantOp getSInt64(uint64_t c, mlir::Location loc) {
     cir::IntType sInt64Ty = getSInt64Ty();
-    return create<cir::ConstantOp>(loc, cir::IntAttr::get(sInt64Ty, c));
+    return cir::ConstantOp::create(*this, loc, cir::IntAttr::get(sInt64Ty, c));
   }
 
   // Creates constant nullptr for pointer type ty.
@@ -401,7 +401,7 @@ class CIRGenBuilderTy : public cir::CIRBaseBuilderTy {
       ptr = createPtrBitcast(ptr, ty);
     uint64_t alignment = align ? align->value() : 0;
     mlir::IntegerAttr alignAttr = getAlignmentAttr(alignment);
-    return create<cir::LoadOp>(loc, ptr, /*isDeref=*/false,
+    return cir::LoadOp::create(*this, loc, ptr, /*isDeref=*/false,
                                /*isVolatile=*/false, alignAttr,
                                /*mem_order=*/cir::MemOrderAttr{});
   }

clang/lib/CIR/CodeGen/CIRGenClass.cpp

@@ -339,12 +339,10 @@ static Address applyNonVirtualAndVirtualOffset(
 
   mlir::Value ptr = addr.getPointer();
   mlir::Type charPtrType = cgf.cgm.UInt8PtrTy;
-  mlir::Value charPtr =
-      cgf.getBuilder().createCast(cir::CastKind::bitcast, ptr, charPtrType);
+  mlir::Value charPtr = cgf.getBuilder().createBitcast(ptr, charPtrType);
   mlir::Value adjusted = cir::PtrStrideOp::create(
       cgf.getBuilder(), loc, charPtrType, charPtr, baseOffset);
-  ptr = cgf.getBuilder().createCast(cir::CastKind::bitcast, adjusted,
-                                    ptr.getType());
+  ptr = cgf.getBuilder().createBitcast(adjusted, ptr.getType());
 
   // If we have a virtual component, the alignment of the result will
   // be relative only to the known alignment of that vbase.
@@ -846,13 +844,13 @@ mlir::Value CIRGenFunction::getVTTParameter(GlobalDecl gd, bool forVirtualBase,
   if (cgm.getCXXABI().needsVTTParameter(curGD)) {
     // A VTT parameter was passed to the constructor, use it.
     mlir::Value vtt = loadCXXVTT();
-    return cgm.getBuilder().createVTTAddrPoint(loc, vtt.getType(), vtt,
+    return builder.createVTTAddrPoint(loc, vtt.getType(), vtt,
                                                subVTTIndex);
   } else {
     // We're the complete constructor, so get the VTT by name.
     cir::GlobalOp vtt = cgm.getVTables().getAddrOfVTT(rd);
-    return cgm.getBuilder().createVTTAddrPoint(
-        loc, cgm.getBuilder().getPointerTo(cgm.VoidPtrTy),
+    return builder.createVTTAddrPoint(
+        loc, builder.getPointerTo(cgm.VoidPtrTy),
         mlir::FlatSymbolRefAttr::get(vtt.getSymNameAttr()), subVTTIndex);
   }
 }

clang/lib/CIR/CodeGen/CIRGenFunction.h

@@ -638,8 +638,8 @@ class CIRGenFunction : public CIRGenTypeCache {
       llvm::iterator_range<CastExpr::path_const_iterator> path,
       bool nullCheckValue, SourceLocation loc);
 
-  /// GetVTTParameter - Return the VTT parameter that should be passed to a
-  /// base constructor/destructor with virtual bases.
+  /// Return the VTT parameter that should be passed to a base
+  /// constructor/destructor with virtual bases.
   /// FIXME: VTTs are Itanium ABI-specific, so the definition should move
   /// to ItaniumCXXABI.cpp together with all the references to VTT.
   mlir::Value getVTTParameter(GlobalDecl gd, bool forVirtualBase,

clang/lib/CIR/CodeGen/CIRGenItaniumCXXABI.cpp

@@ -656,26 +656,27 @@ bool CIRGenItaniumCXXABI::isVirtualOffsetNeededForVTableField(
 mlir::Value CIRGenItaniumCXXABI::getVirtualBaseClassOffset(
     mlir::Location loc, CIRGenFunction &cgf, Address thisAddr,
     const CXXRecordDecl *classDecl, const CXXRecordDecl *baseClassDecl) {
+  CIRGenBuilderTy &builder = cgf.getBuilder();
   mlir::Value vtablePtr = cgf.getVTablePtr(loc, thisAddr, classDecl);
   mlir::Value vtableBytePtr =
-      cgf.getBuilder().createBitcast(vtablePtr, cgm.UInt8PtrTy);
+      builder.createBitcast(vtablePtr, cgm.UInt8PtrTy);
   CharUnits vbaseOffsetOffset =
       cgm.getItaniumVTableContext().getVirtualBaseOffsetOffset(classDecl,
                                                                baseClassDecl);
   mlir::Value offsetVal =
-      cgf.getBuilder().getSInt64(vbaseOffsetOffset.getQuantity(), loc);
+      builder.getSInt64(vbaseOffsetOffset.getQuantity(), loc);
   auto vbaseOffsetPtr =
-      cir::PtrStrideOp::create(cgf.getBuilder(), loc, cgm.UInt8PtrTy,
+      cir::PtrStrideOp::create(builder, loc, cgm.UInt8PtrTy,
                                vtableBytePtr, offsetVal); // vbase.offset.ptr
 
   mlir::Value vbaseOffset;
   if (cgm.getItaniumVTableContext().isRelativeLayout()) {
     assert(!cir::MissingFeatures::vtableRelativeLayout());
     cgm.errorNYI(loc, "getVirtualBaseClassOffset: relative layout");
   } else {
-    mlir::Value offsetPtr = cgf.getBuilder().createBitcast(
-        vbaseOffsetPtr, cgf.getBuilder().getPointerTo(cgm.PtrDiffTy));
-    vbaseOffset = cgf.getBuilder().createLoad(
+    mlir::Value offsetPtr = builder.createBitcast(
+        vbaseOffsetPtr, builder.getPointerTo(cgm.PtrDiffTy));
+    vbaseOffset = builder.createLoad(
         loc, Address(offsetPtr, cgm.PtrDiffTy,
                      cgf.getPointerAlign())); // vbase.offset
   }