[mlir][evm] Lower the remaining builtins

This includes:

  extcodecopy
  extcodehash
  balance
  selfbalance
  chainid
  basefee
  blobbasefee
  origin
  gasprice
  blockhash
  blobhash
  coinbase
  timestamp
  number
  prevrandao
  gaslimit
  callcode

Author: PavelKopyl

libsolidity/codegen/mlir/Target/EVM/YulToStandard.cpp

@@ -174,6 +174,32 @@ struct AddressOpLowering : public OpRewritePattern<yul::AddressOp> {
   }
 };
 
+struct BalanceOpLowering : public OpRewritePattern<yul::BalanceOp> {
+  using OpRewritePattern<yul::BalanceOp>::OpRewritePattern;
+
+  LogicalResult matchAndRewrite(yul::BalanceOp op,
+                                PatternRewriter &r) const override {
+    r.replaceOpWithNewOp<LLVM::IntrCallOp>(op, llvm::Intrinsic::evm_balance,
+                                           /*resTy=*/r.getIntegerType(256),
+                                           /*ins=*/ValueRange{op.getAddr()},
+                                           "evm.balance");
+    return success();
+  }
+};
+
+struct SelfBalanceOpLowering : public OpRewritePattern<yul::SelfBalanceOp> {
+  using OpRewritePattern<yul::SelfBalanceOp>::OpRewritePattern;
+
+  LogicalResult matchAndRewrite(yul::SelfBalanceOp op,
+                                PatternRewriter &r) const override {
+    r.replaceOpWithNewOp<LLVM::IntrCallOp>(op, llvm::Intrinsic::evm_selfbalance,
+                                           /*resTy=*/r.getIntegerType(256),
+                                           /*ins=*/ValueRange{},
+                                           "evm.selfbalance");
+    return success();
+  }
+};
+
 struct CallerOpLowering : public OpRewritePattern<yul::CallerOp> {
   using OpRewritePattern<yul::CallerOp>::OpRewritePattern;
 
@@ -199,6 +225,159 @@ struct GasOpLowering : public OpRewritePattern<yul::GasOp> {
   }
 };
 
+struct ChainIdOpLowering : public OpRewritePattern<yul::ChainIdOp> {
+  using OpRewritePattern<yul::ChainIdOp>::OpRewritePattern;
+
+  LogicalResult matchAndRewrite(yul::ChainIdOp op,
+                                PatternRewriter &r) const override {
+    r.replaceOpWithNewOp<LLVM::IntrCallOp>(op, llvm::Intrinsic::evm_chainid,
+                                           /*resTy=*/r.getIntegerType(256),
+                                           /*ins=*/ValueRange{}, "evm.chainid");
+    return success();
+  }
+};
+
+struct BaseFeeOpLowering : public OpRewritePattern<yul::BaseFeeOp> {
+  using OpRewritePattern<yul::BaseFeeOp>::OpRewritePattern;
+
+  LogicalResult matchAndRewrite(yul::BaseFeeOp op,
+                                PatternRewriter &r) const override {
+    r.replaceOpWithNewOp<LLVM::IntrCallOp>(op, llvm::Intrinsic::evm_basefee,
+                                           /*resTy=*/r.getIntegerType(256),
+                                           /*ins=*/ValueRange{}, "evm.basefee");
+    return success();
+  }
+};
+
+struct BlobBaseFeeOpLowering : public OpRewritePattern<yul::BlobBaseFeeOp> {
+  using OpRewritePattern<yul::BlobBaseFeeOp>::OpRewritePattern;
+
+  LogicalResult matchAndRewrite(yul::BlobBaseFeeOp op,
+                                PatternRewriter &r) const override {
+    r.replaceOpWithNewOp<LLVM::IntrCallOp>(op, llvm::Intrinsic::evm_blobbasefee,
+                                           /*resTy=*/r.getIntegerType(256),
+                                           /*ins=*/ValueRange{},
+                                           "evm.blobbasefee");
+    return success();
+  }
+};
+
+struct OriginOpLowering : public OpRewritePattern<yul::OriginOp> {
+  using OpRewritePattern<yul::OriginOp>::OpRewritePattern;
+
+  LogicalResult matchAndRewrite(yul::OriginOp op,
+                                PatternRewriter &r) const override {
+    r.replaceOpWithNewOp<LLVM::IntrCallOp>(op, llvm::Intrinsic::evm_origin,
+                                           /*resTy=*/r.getIntegerType(256),
+                                           /*ins=*/ValueRange{}, "evm.origin");
+    return success();
+  }
+};
+
+struct GasPriceOpLowering : public OpRewritePattern<yul::GasPriceOp> {
+  using OpRewritePattern<yul::GasPriceOp>::OpRewritePattern;
+
+  LogicalResult matchAndRewrite(yul::GasPriceOp op,
+                                PatternRewriter &r) const override {
+    r.replaceOpWithNewOp<LLVM::IntrCallOp>(op, llvm::Intrinsic::evm_gasprice,
+                                           /*resTy=*/r.getIntegerType(256),
+                                           /*ins=*/ValueRange{},
+                                           "evm.gasprice");
+    return success();
+  }
+};
+
+struct BlockHashOpLowering : public OpRewritePattern<yul::BlockHashOp> {
+  using OpRewritePattern<yul::BlockHashOp>::OpRewritePattern;
+
+  LogicalResult matchAndRewrite(yul::BlockHashOp op,
+                                PatternRewriter &r) const override {
+    r.replaceOpWithNewOp<LLVM::IntrCallOp>(op, llvm::Intrinsic::evm_blockhash,
+                                           /*resTy=*/r.getIntegerType(256),
+                                           /*ins=*/ValueRange{op.getBlock()},
+                                           "evm.blockhash");
+    return success();
+  }
+};
+
+struct BlobHashOpLowering : public OpRewritePattern<yul::BlobHashOp> {
+  using OpRewritePattern<yul::BlobHashOp>::OpRewritePattern;
+
+  LogicalResult matchAndRewrite(yul::BlobHashOp op,
+                                PatternRewriter &r) const override {
+    r.replaceOpWithNewOp<LLVM::IntrCallOp>(op, llvm::Intrinsic::evm_blobhash,
+                                           /*resTy=*/r.getIntegerType(256),
+                                           /*ins=*/ValueRange{op.getIdx()},
+                                           "evm.blobhash");
+    return success();
+  }
+};
+
+struct CoinBaseOpLowering : public OpRewritePattern<yul::CoinBaseOp> {
+  using OpRewritePattern<yul::CoinBaseOp>::OpRewritePattern;
+
+  LogicalResult matchAndRewrite(yul::CoinBaseOp op,
+                                PatternRewriter &r) const override {
+    r.replaceOpWithNewOp<LLVM::IntrCallOp>(op, llvm::Intrinsic::evm_coinbase,
+                                           /*resTy=*/r.getIntegerType(256),
+                                           /*ins=*/ValueRange{},
+                                           "evm.coinbase");
+    return success();
+  }
+};
+
+struct TimeStampOpLowering : public OpRewritePattern<yul::TimeStampOp> {
+  using OpRewritePattern<yul::TimeStampOp>::OpRewritePattern;
+
+  LogicalResult matchAndRewrite(yul::TimeStampOp op,
+                                PatternRewriter &r) const override {
+    r.replaceOpWithNewOp<LLVM::IntrCallOp>(op, llvm::Intrinsic::evm_timestamp,
+                                           /*resTy=*/r.getIntegerType(256),
+                                           /*ins=*/ValueRange{},
+                                           "evm.timestamp");
+    return success();
+  }
+};
+
+struct NumberOpLowering : public OpRewritePattern<yul::NumberOp> {
+  using OpRewritePattern<yul::NumberOp>::OpRewritePattern;
+
+  LogicalResult matchAndRewrite(yul::NumberOp op,
+                                PatternRewriter &r) const override {
+    r.replaceOpWithNewOp<LLVM::IntrCallOp>(op, llvm::Intrinsic::evm_number,
+                                           /*resTy=*/r.getIntegerType(256),
+                                           /*ins=*/ValueRange{}, "evm.number");
+    return success();
+  }
+};
+
+struct PrevrandaoOpLowering : public OpRewritePattern<yul::PrevrandaoOp> {
+  using OpRewritePattern<yul::PrevrandaoOp>::OpRewritePattern;
+
+  LogicalResult matchAndRewrite(yul::PrevrandaoOp op,
+                                PatternRewriter &r) const override {
+    // TODO: fix the intrinsic name in LLVM.
+    r.replaceOpWithNewOp<LLVM::IntrCallOp>(op, llvm::Intrinsic::evm_difficulty,
+                                           /*resTy=*/r.getIntegerType(256),
+                                           /*ins=*/ValueRange{},
+                                           "evm.difficulty");
+    return success();
+  }
+};
+
+struct GasLimitOpLowering : public OpRewritePattern<yul::GasLimitOp> {
+  using OpRewritePattern<yul::GasLimitOp>::OpRewritePattern;
+
+  LogicalResult matchAndRewrite(yul::GasLimitOp op,
+                                PatternRewriter &r) const override {
+    r.replaceOpWithNewOp<LLVM::IntrCallOp>(op, llvm::Intrinsic::evm_gaslimit,
+                                           /*resTy=*/r.getIntegerType(256),
+                                           /*ins=*/ValueRange{},
+                                           "evm.gaslimit");
+    return success();
+  }
+};
+
 struct CallValOpLowering : public OpRewritePattern<yul::CallValOp> {
   using OpRewritePattern<yul::CallValOp>::OpRewritePattern;
 
@@ -424,6 +603,19 @@ struct ExtCodeCopyOpLowering : public OpRewritePattern<yul::ExtCodeCopyOp> {
   }
 };
 
+struct ExtCodeHashOpLowering : public OpRewritePattern<yul::ExtCodeHashOp> {
+  using OpRewritePattern<yul::ExtCodeHashOp>::OpRewritePattern;
+
+  LogicalResult matchAndRewrite(yul::ExtCodeHashOp op,
+                                PatternRewriter &r) const override {
+    r.replaceOpWithNewOp<LLVM::IntrCallOp>(op, llvm::Intrinsic::evm_extcodehash,
+                                           /*resTy=*/r.getIntegerType(256),
+                                           /*ins=*/op.getAddr(),
+                                           "evm.extcodehash");
+    return success();
+  }
+};
+
 struct CreateOpLowering : public OpRewritePattern<yul::CreateOp> {
   using OpRewritePattern<yul::CreateOp>::OpRewritePattern;
 
@@ -652,6 +844,25 @@ struct BuiltinCallOpLowering : public OpRewritePattern<yul::CallOp> {
   }
 };
 
+struct CallCodeOpLowering : public OpRewritePattern<yul::CallCodeOp> {
+  using OpRewritePattern<yul::CallCodeOp>::OpRewritePattern;
+
+  LogicalResult matchAndRewrite(yul::CallCodeOp op,
+                                PatternRewriter &r) const override {
+    evm::Builder evmB(r, op.getLoc());
+
+    r.replaceOpWithNewOp<LLVM::IntrCallOp>(
+        op, llvm::Intrinsic::evm_callcode,
+        /*resTy=*/r.getIntegerType(256),
+        /*ins=*/
+        ValueRange{op.getGas(), op.getAddress(), op.getValue(),
+                   evmB.genHeapPtr(op.getInpOffset()), op.getInpSize(),
+                   evmB.genHeapPtr(op.getOutOffset()), op.getOutSize()},
+        "evm.callcode");
+    return success();
+  }
+};
+
 struct StaticCallOpLowering : public OpRewritePattern<yul::StaticCallOp> {
   using OpRewritePattern<yul::StaticCallOp>::OpRewritePattern;
 
@@ -795,8 +1006,22 @@ void evm::populateYulPats(RewritePatternSet &pats) {
       SignExtendOpLowering,
       LogOpLowering,
       AddressOpLowering,
+      BalanceOpLowering,
+      SelfBalanceOpLowering,
       CallerOpLowering,
       GasOpLowering,
+      ChainIdOpLowering,
+      BaseFeeOpLowering,
+      BlobBaseFeeOpLowering,
+      OriginOpLowering,
+      GasPriceOpLowering,
+      BlockHashOpLowering,
+      BlobHashOpLowering,
+      CoinBaseOpLowering,
+      TimeStampOpLowering,
+      NumberOpLowering,
+      PrevrandaoOpLowering,
+      GasLimitOpLowering,
       RevertOpLowering,
       StopOpLowering,
       CallValOpLowering,
@@ -815,6 +1040,7 @@ void evm::populateYulPats(RewritePatternSet &pats) {
       CodeCopyOpLowering,
       ExtCodeSizeOpLowering,
       ExtCodeCopyOpLowering,
+      ExtCodeHashOpLowering,
       CreateOpLowering,
       Create2OpLowering,
       MLoadOpLowering,
@@ -828,6 +1054,7 @@ void evm::populateYulPats(RewritePatternSet &pats) {
       MCopyOpLowering,
       MemGuardOpLowering,
       BuiltinCallOpLowering,
+      CallCodeOpLowering,
       StaticCallOpLowering,
       DelegateCallOpLowering,
       BuiltinRetOpLowering,