[mlir][Sol] Support packed and unpacked string storage layouts

This also adds support for:
- Short strings (length < 32 bytes, packed encoding)
- Long strings (length >= 32 bytes, unpacked encoding)
- String operations: push(), push(x), pop(), length, indexing
- Conversions between memory and storage representations

Author: PavelKopyl

mlir/include/mlir/Conversion/SolToStandard/EVMUtil.h

@@ -164,13 +164,21 @@ class Builder {
 
   /// Generates {slot, offset} for packed storage array indexing.
   Value genPackedStorageAddr(Value baseSlot, Value idx, Type eltTy,
+                             bool isDataLeftAligned = false,
                              std::optional<Location> locArg = std::nullopt);
 
   /// Loads slot and punches hole: and(sload(slot), holeMask)
   /// where holeMask = not(ones(numBits) << shiftBits)
   Value genPunchHole(Value slot, Value shiftBits, unsigned numBits,
                      std::optional<Location> locArg = std::nullopt);
 
+  /// Inserts integer value (<=32 bytes) to the slot value:
+  /// or(and(slot, holeMask), shiftedVal), where
+  /// holeMask = not(ones(numBits) << offset * 8),
+  /// shiftedVal = (intVal << offset * 8)
+  Value genInsertIntToSlot(Value slot, Value offset, Value intVal,
+                           unsigned numBits, std::optional<Location> locArg);
+
   /// Generates a load from the low level integral type address.
   Value genLoad(Value addr, sol::DataLocation dataLoc,
                 std::optional<Location> locArg = std::nullopt);
@@ -187,12 +195,49 @@ class Builder {
   void genStringStore(std::string const &str, Value addr,
                       std::optional<Location> locArg = std::nullopt);
 
-  /// Generates a loop to copy the data. This works for low level integral type
-  /// addresses.
-  void genCopyLoop(Value srcAddr, Value dstAddr, Value sizeInWords, Type srcTy,
-                   Type dstTy, sol::DataLocation srcDataLoc,
-                   sol::DataLocation dstDataLoc,
-                   std::optional<Location> locArg = std::nullopt);
+  /// Generates length of a string.
+  mlir::Value
+  genStringLength(mlir::Value lengthSlot, mlir::sol::DataLocation dataLoc,
+                  std::optional<mlir::Location> locArg = std::nullopt);
+
+  /// Copies a string to the memory.
+  void
+  genCopyStringToMemory(mlir::Value srcDataAddr, mlir::Value lengthSlot,
+                        mlir::Value length, mlir::Value dstAddr,
+                        mlir::sol::DataLocation srcDataLoc,
+                        std::optional<mlir::Location> locArg = std::nullopt);
+
+  /// Copies a string to the storage.
+  void
+  genCopyStringToStorage(mlir::Value srcDataAddr, mlir::Value lengthSlot,
+                         mlir::Value length, mlir::Value dstAddr,
+                         mlir::sol::DataLocation srcDataLoc,
+                         std::optional<mlir::Location> locArg = std::nullopt);
+
+  /// Copies an object of type \p ty from \p srcAddr to \p dstAddr.
+  void genCopy(mlir::Type ty, mlir::Value srcAddr, mlir::Value dstAddr,
+               mlir::sol::DataLocation srcDataLoc,
+               mlir::sol::DataLocation dstDataLoc,
+               std::optional<mlir::Location> locArg = std::nullopt);
+
+  /// Generates the 'push' of a value to string.
+  void genPushToString(mlir::Value srcAddr, mlir::Value value,
+                       std::optional<mlir::Location> locArg = std::nullopt);
+
+  /// Generates the 'push' of a default value to string and
+  /// returns a fat pointer to the newly added element.
+  Value
+  genPushVoidToString(Value srcAddr,
+                      std::optional<mlir::Location> locArg = std::nullopt);
+
+  /// Generates the 'pop' for string.
+  void genPopString(mlir::Value srcAddr, mlir::Value oldData,
+                    mlir::Value length,
+                    std::optional<mlir::Location> locArg = std::nullopt);
+
+  /// Generates {slot, offset} for string storage indexing.
+  Value genStringItemAddress(mlir::Value srcAddr, mlir::Value idx,
+                             std::optional<Location> locArg = std::nullopt);
 
   /// Generates an assertion that the tuple size should be less than `size`.
   void genABITupleSizeAssert(TypeRange tys, Value size,

mlir/include/mlir/Conversion/SolToStandard/Util.h

@@ -154,6 +154,18 @@ class BuilderExt {
         loc, add, genI256Const(~(llvm::APInt(/*numBits=*/256, multiple - 1))));
   }
 
+  /// Generates the ceiling of value / multiple (power-of-2).
+  template <unsigned multiple>
+  mlir::Value
+  genCeilDivision(mlir::Value val,
+                  std::optional<mlir::Location> locArg = std::nullopt) {
+    static_assert(llvm::isPowerOf2_32(multiple));
+    mlir::Location loc = locArg ? *locArg : defLoc;
+    auto add =
+        b.create<mlir::arith::AddIOp>(loc, val, genI256Const(multiple - 1));
+    return b.create<mlir::arith::DivUIOp>(loc, add, genI256Const(multiple));
+  }
+
   /// Returns an existing or a new (if not found) FuncOp in the ModuleOp `mod`.
   sol::FuncOp getOrInsertFuncOp(StringRef name, FunctionType fnTy,
                                 LLVM::Linkage linkage, ModuleOp mod,

mlir/include/mlir/Dialect/Sol/SolOps.td

@@ -207,6 +207,36 @@ def Sol_PushOp : Sol_Op<"push"> {
   let assemblyFormat = "$inp attr-dict `:` type($inp) `->` type($addr)";
 }
 
+// String push operations are separate from Sol_PushOp because Solidity strings
+// use a dual storage encoding that requires special handling:
+//
+//   - Short strings (< 32 bytes): data and length are packed into a single
+//     storage slot ("in-place" encoding).
+//   - Long strings (>= 32 bytes): the slot holds `length * 2 + 1` and the
+//     byte data is stored starting at keccak256(slot) ("out-of-place"
+//     encoding).
+//
+// Appending a byte may trigger a transition from in-place to out-of-place
+// encoding at the 31-byte boundary, which generic Sol_PushOp does not handle.
+//
+// The two ops correspond to Solidity's two push() overloads on dynamic byte
+// arrays:
+//   - Sol_PushStringOp    : str.push(x) -- appends a specific byte value.
+//   - Sol_PushOp          : str.push()  -- appends a zero byte and returns a
+//     storage reference ({slot, offset}) to the new element so the caller can
+//     write to it later.
+// We have two separate operations because implementing push(x) as push() = x
+// would introduce significant gas overhead. Storage would need to be read and
+// written twice: first when updating the length of the packed string
+// (inside push()), and again when inserting the new value.
+//
+def Sol_PushStringOp : Sol_Op<"push_string"> {
+  let arguments = (ins Sol_StringType:$addr,
+      AnyTypeOf<[Sol_BytesType, Sol_Int]>:$value);
+  let assemblyFormat =
+      "$addr `,` $value attr-dict `:` type($addr) `,` type($value)";
+}
+
 def Sol_PopOp : Sol_Op<"pop"> {
   let arguments = (ins AnyType:$inp);
   let assemblyFormat = "$inp attr-dict `:` type($inp)";