[MLIR] Generic 'malloc', 'aligned_alloc' and 'free' functions

[mscuttari]

Summary

When converted to the LLVM dialect, the memref.alloc and memref.free operations were generating calls to hardcoded 'malloc' and 'free' functions. This didn't leave any freedom to users to provide their custom implementation. Those operations now convert into calls to '_mlir_alloc' and '_mlir_free' functions, which have also been implemented into the runtime support library as wrappers to 'malloc' and 'free'. The same has been done for the 'aligned_alloc' function.

[lxsameer]

It would be nice to have this feature documented in the official docs.

[mscuttari]

In D128791#3618161, @lxsameer wrote:

It would be nice to have this feature documented in the official docs.

You're right, I will proceed in doing that.

[mscuttari]

When using JIT compilation, the _mlir_alloc and _mlir_free were not solved due to the missing runtime library. A new command line option has been added to get it loaded, and the tests have been updated accordingly.

[mscuttari]

Fix code formatting

[mscuttari]

In D128791#3618161, @lxsameer wrote:

It would be nice to have this feature documented in the official docs.

Well, I see that the official MLIR documentation is on another repo (mlir-www), so I think it should be better to patch it only when this modification lands. To be honest I don't know if I've to go through Phabricator to patch mlir-www, I've never done that.

[mscuttari]

Fix formatting

[myhsu]

I think you accidentally override the main patch, I can only see changes in the example files

[mscuttari]

Patch fix.

[mscuttari]

In D128791#3620465, @myhsu wrote:

I think you accidentally override the main patch, I can only see changes in the example files

First time using Phabricator, sorry. I made multiple commits to fix various problems, and each time uploaded a patch made with

git show HEAD -U999999 > mypatch.patch

Seems like it's not the way to go though. Please check if now it's ok, I've squashed all the changes into a single commit

[mscuttari]

Fix formatting

[myhsu]

In D128791#3621491, @mscuttari wrote:

In D128791#3620465, @myhsu wrote:

I think you accidentally override the main patch, I can only see changes in the example files

First time using Phabricator, sorry. I made multiple commits to fix various problems, and each time uploaded a patch made with

Right, we are using a different model than, say, GitHub PR. One of the reasons being that LLVM requires every commit to be buildable and able to pass all the tests, so one can't just stack new commits to update their changes. We, however, encourage people to split big changes into multiple patches, but of course each of them still needs to be buildable and passing all tests.

git show HEAD -U999999 > mypatch.patch

Seems like it's not the way to go though. Please check if now it's ok, I've squashed all the changes into a single commit

Usually I use git rebase to amend changes to a commit.

[myhsu]

Can you put some documentations (at mlir/docs) regarding this change? Otherwise LGTM.

mlir/examples/toy/Ch6/toyc.cpp

246

format: remove braces. https://llvm.org/docs/CodingStandards.html#don-t-use-braces-on-simple-single-statement-bodies-of-if-else-loop-statements

mlir/examples/toy/Ch7/toyc.cpp

247

ditto

[mscuttari]

Documentation updated & code style improvements

[mscuttari]

In D128791#3622897, @myhsu wrote:

Can you put some documentations (at mlir/docs) regarding this change? Otherwise LGTM.

I added a few lines into the Toy example documentation, please let me know if it's ok.

[mscuttari]

Ping. Unfortunately I do not have commit permissions so I need someone to commit the changes

[ftynse]

I am not very happy about exposing the complexity of shared libs and runnerutils to the tutorial. Can we just have a simple post-hoc transform (pass or just some helper code in the to JIT that goes through the symbol table of the module and renames _mlir_alloc back to malloc for the sake of simplicity. We can still mention that this is happening in the documentation and why, but it really looks desirable to avoid the complexity of shared library loading in the tutorial.

mlir/docs/Tutorials/Toy/Ch-6.md

174–176

Nit: please wrap at 80 cols.

[mscuttari]

Toy example: pass to rename '_mlir_alloc' into 'malloc' and '_mlir_free' into 'free'

[mscuttari]

In D128791#3638442, @ftynse wrote:

I am not very happy about exposing the complexity of shared libs and runnerutils to the tutorial. Can we just have a simple post-hoc transform (pass or just some helper code in the to JIT that goes through the symbol table of the module and renames _mlir_alloc back to malloc for the sake of simplicity. We can still mention that this is happening in the documentation and why, but it really looks desirable to avoid the complexity of shared library loading in the tutorial.

I've introduced a small transformation pass into the Toy example, and fixed the documentation of chapter 6 accordingly.

[mscuttari]

Code formatting

[mscuttari]

MSVC's implementation of the standard library doesn't provide the aligned_alloc function, despite it being part of the standard. Instead, it provides an _aligned_malloc function. Moreover, MSVC also requires the pointers obtained through _aligned_malloc to be deallocated through _aligned_free, and not free.

[mscuttari]

Ping

[ftynse]

Sorry for the delay.

[mscuttari]

In D128791#3659984, @ftynse wrote:

Sorry for the delay.

No problem. However I will need someone to commit the patch, I do not have the rights to do it by myself

[ftynse]

Could you please provide your name and email as they should be written in the git commit?

[mscuttari]

Yes sure:

Michele Scuttari
[e-mail]

Thanks

[mehdi_amini]

I had to revert: all the integration tests are broken. Try to reconfigure your build dir with -DMLIR_INCLUDE_INTEGRATION_TESTS=ON

[silvas]

FYI this caused us issues in Torch-MLIR as well https://github.com/llvm/torch-mlir/pull/1078#issuecomment-1188337337

I'm a little worried about the direction on this change -- LLVM already permits malloc/free to be treated specially, so I don't see why we need to do this renaming at the MLIR level. I think the fact that we needed a special pass to keep the Toy example running indicates that this is going in the wrong direction (we should not be moving towards making tutorials more complicated / less "just works" unless there is a very good reason). It seems like the better direction would be to provide a pass that replaces malloc and free with _mlir_malloc/free which users can hook into the pipeline if they desire the renaming -- this pass could even be an LLVM IR pass.

[mscuttari]

In D128791#3661185, @silvas wrote:

FYI this caused us issues in Torch-MLIR as well https://github.com/llvm/torch-mlir/pull/1078#issuecomment-1188337337

I'm a little worried about the direction on this change -- LLVM already permits malloc/free to be treated specially, so I don't see why we need to do this renaming at the MLIR level. I think the fact that we needed a special pass to keep the Toy example running indicates that this is going in the wrong direction (we should not be moving towards making tutorials more complicated / less "just works" unless there is a very good reason). It seems like the better direction would be to provide a pass that replaces malloc and free with _mlir_malloc/free which users can hook into the pipeline if they desire the renaming -- this pass could even be an LLVM IR pass.

I'm sorry for the issues, I didn't know about the MLIR_INCLUDE_INTEGRATION_TESTS option and neither I could find it documented anywhere, so I thought that passing the Phabricator builds and the mlir-check target tests was enough to ensure I didn't break anything.
I can try implementing the pass you mentioned, which basically is the opposite of what is done inside the Toy example. At that point, however, I don't know if it has a reason to exist at all and if it should instead left to be implemented by the user.
The rationale behind this change was to avoid sticking to malloc and free, which seem like first-class citizens if one ignores that the standard library is automatically linked (same story for the printf function, which is the Toy example). Also, there are some caveats such as the aligned_alloc function, which MSVC's implementation does not provide (yet is used by MLIR in some places), and also imply different deallocation calls. For this last issue, however, we can just keep the related part of the patch, if you think it may be useful (at that point, however, there would be a naming inconsistency which I don't know how much we would like).
Anyway thank you for your share, I've been using MLIR as a user for the last two years but I'm quite new in delivering changes upstream, so I would really apreciate more opinions on this topic so that we can decide the path to take (in which doing nothing is absolutely one of them, if you believe so).

[mehdi_amini]

In D128791#3661671, @mscuttari wrote:

I'm sorry for the issues, I didn't know about the MLIR_INCLUDE_INTEGRATION_TESTS option and neither I could find it documented anywhere, so I thought that passing the Phabricator builds and the mlir-check target tests was enough to ensure I didn't break anything.

Don't worry: it is hard to not break "something".
For example we also have a bot running code on GPUs which you may not be able to test locally if you don't have a Nvidia GPU. We also have some bots that are big endian which again you may have a hard time running locally.

[mehdi_amini]

One thing though: be on the lookout in the next hour after pushing a change, you may get email notifications from bots that are broken. You'll need to determine if it is related to your patch (sometimes multiple changes get landed closely together and the bot would test them together) and quickly fix forward or revert.

[ftynse]

There was a forum post and nobody really raised any objection to the direction there -- https://discourse.llvm.org/t/llvm-dialect-replacing-malloc-and-free-with-custom-functions/63481. FWIW, the original lowering of memref allocs did use custom functions -- https://github.com/llvm/llvm-project/commit/90d1b6b5f25e66059be5be1f9badcbc5a37c356b. It was later silently changed in https://github.com/llvm/llvm-project/commit/e9493cf14deec4198a3620d734f03e7e143f91d6, with as motivation being able to run a JIT without a support library. IMO, we (well, I as the commit author) took a shortcut there. A custom function lets us intercept and customize specifically the allocations coming from the memref dialect and ignore everything else. A pass that would renamed malloc to _mlir_alloc will also do so for legitimate user calls to malloc, and it may not be what we want. Maybe we can have a binary switch the lowering pass between emitting _mlir_alloc and malloc, defaulting to _mlir_alloc as the more scalable approach. Same as we have the non-default bare pointer calling convention that the user may opt into if their case is simple enough. This is slightly better than having to inject function names as strings through pass options.

[mscuttari]

In D128791#3662012, @mehdi_amini wrote:

One thing though: be on the lookout in the next hour after pushing a change, you may get email notifications from bots that are broken. You'll need to determine if it is related to your patch (sometimes multiple changes get landed closely together and the bot would test them together) and quickly fix forward or revert.

Probably I didn't receive any notification because I asked Alex to commit it. The next times I will pay attention to the Actions list on github and see if anything strange happens.
Just to confirm: the bots leveraged by Phabricator do check if the build process succeeds, but they do not run the tests? Because I was getting a green check when I was uploading my patches, and that made me believe everything was fine.

In D128791#3662641, @ftynse wrote:

Maybe we can have a binary switch the lowering pass between emitting _mlir_alloc and malloc, defaulting to _mlir_alloc as the more scalable approach. Same as we have the non-default bare pointer calling convention that the user may opt into if their case is simple enough. This is slightly better than having to inject function names as strings through pass options.

I will look into this asap.

[ftynse]

In D128791#3662711, @mscuttari wrote:

In D128791#3662012, @mehdi_amini wrote:

Probably I didn't receive any notification because I asked Alex to commit it. The next times I will pay attention to the Actions list on github and see if anything strange happens.
Just to confirm: the bots leveraged by Phabricator do check if the build process succeeds, but they do not run the tests? Because I was getting a green check when I was uploading my patches, and that made me believe everything was fine.

I did not receive it either. The email gets sent to the address associated with the commit, the one you gave is @users.noreply.github.com so the email was most likely bounced by GitHub. IIRC, there was a way to get a "reply" email from github that gets forwarded somewhere.
Some notifications don't go through GitHub, so it's better to check the email...

In D128791#3662641, @ftynse wrote:

Maybe we can have a binary switch the lowering pass between emitting _mlir_alloc and malloc, defaulting to _mlir_alloc as the more scalable approach. Same as we have the non-default bare pointer calling convention that the user may opt into if their case is simple enough. This is slightly better than having to inject function names as strings through pass options.

I will look into this asap.

Thanks!

[mscuttari]

In D128791#3662728, @ftynse wrote:

I did not receive it either. The email gets sent to the address associated with the commit, the one you gave is @users.noreply.github.com so the email was most likely bounced by GitHub. IIRC, there was a way to get a "reply" email from github that gets forwarded somewhere.
Some notifications don't go through GitHub, so it's better to check the email...

Oh well you're right. I usually get notifications in case of CI failures on my project but, being the bots external, the email surely got reject by Github. Next time I will provide you my personal email (maybe privately) so I can get notified in case of problems and still have it linked to the account.

[ftynse]

If you upload patches using Arcanist, the email in your commit will get included in the diff metadata and I will be able to use it directly.

[mehdi_amini]

In D128791#3662711, @mscuttari wrote:

Just to confirm: the bots leveraged by Phabricator do check if the build process succeeds, but they do not run the tests? Because I was getting a green check when I was uploading my patches, and that made me believe everything was fine.

It runs the usual tests, but likely not the integration one? (that is it does not have the CMake option I mentioned to you).

[silvas]

In D128791#3662641, @ftynse wrote:

There was a forum post and nobody really raised any objection to the direction there -- https://discourse.llvm.org/t/llvm-dialect-replacing-malloc-and-free-with-custom-functions/63481. FWIW, the original lowering of memref allocs did use custom functions -- https://github.com/llvm/llvm-project/commit/90d1b6b5f25e66059be5be1f9badcbc5a37c356b. It was later silently changed in https://github.com/llvm/llvm-project/commit/e9493cf14deec4198a3620d734f03e7e143f91d6, with as motivation being able to run a JIT without a support library. IMO, we (well, I as the commit author) took a shortcut there. A custom function lets us intercept and customize specifically the allocations coming from the memref dialect and ignore everything else. A pass that would renamed malloc to _mlir_alloc will also do so for legitimate user calls to malloc, and it may not be what we want. Maybe we can have a binary switch the lowering pass between emitting _mlir_alloc and malloc, defaulting to _mlir_alloc as the more scalable approach. Same as we have the non-default bare pointer calling convention that the user may opt into if their case is simple enough. This is slightly better than having to inject function names as strings through pass options.

In that case I think we should call it _mlir_memref_dialect_alloc and not _mlir_alloc.

I still think that things should "just work" and customizations like this should be graceful improvements rather than up-front cognitive burden for all users. So having this as a flag (default no change from current behavior) and very specific to the memref dialect to LLVM conversion would be ideal in my mind.

[mscuttari]

Option inside MemRef -> LLVM conversion pass

'use-generic-function' option inside the MemRef -> LLVM conversion pass to enable
the usage of generic allocation / deallocation functions. When set to true,
'_mlir_alloc' is used instead of 'malloc', '_mlir_aligned_alloc' instead of
'aligned_alloc' and '_mlir_free' instead of 'free'. The option defaults to false.

[mscuttari]

Well I'm sorry for the stupid question but I'm quite confused. I switched to Arcanist but things seem to be messed up.
I made the changes we agreed on, committed them, reopened the revision and finally run arc diff --update D128791.
Still the changes seem to be the older ones, and I see no trace of the last diff. Can anyone please explain what I'm doing wrong?

EDIT: should be ok now, but still a bit confused about the overall flow, will see if it gets better with future patches

[mscuttari]

Option inside MemRef -> LLVM conversion pass

'use-generic-function' option inside the MemRef -> LLVM conversion pass to enable the usage of generic allocation / deallocation functions. When set to true, '_mlir_alloc' is used instead of 'malloc', '_mlir_aligned_alloc' instead of 'aligned_alloc' and '_mlir_free' instead of 'free'. The option defaults to false.

[mscuttari]

Fix formatting

[ftynse]

I made the changes we agreed on, committed them, reopened the revision and finally run arc diff --update D128791.

You need to specify what you are diff'ing against, e.g., the previous commit HEAD^.

[mscuttari]

In D128791#3675981, @ftynse wrote:

I made the changes we agreed on, committed them, reopened the revision and finally run arc diff --update D128791.

You need to specify what you are diff'ing against, e.g., the previous commit HEAD^.

Oh right, thanks. I completely forgot as I was previously doing the diff manually.
If the patch is good for @silvas (which I think it is, as the default behaviour has been preserved), then I would kindly ask you commit the changes on the repo. You should also now be able to see an email that is different from the github one which I previously wrote. Please tell me if this is not the case, or I will not be able to see problems with the build-bots, if any should ever arise.

[ftynse]

You can always check the build status manually: https://lab.llvm.org/buildbot/#/changes/64333

[silvas]

I would recommend that we rename this to _mlir_memref_to_llvm_alloc, to differentiate it from other situations where MLIR might want a custom allocation function (memref to LLVM is not "MLIR" as whole)

[mscuttari]

In D128791#3677076, @silvas wrote:

I would recommend that we rename this to _mlir_memref_to_llvm_alloc, to differentiate it from other situations where MLIR might want a custom allocation function (memref to LLVM is not "MLIR" as whole)

Alright, I'm sorry but I forgot that, I see now that you already mentioned it in your previous comment.
Newbie question about the Phabricator's workflow: should I open a new revision or reopen this one?

[silvas]

You can open a new one -- thanks!

mlir/docs/Tutorials/Toy/Ch-6.md

^bb18:
   llvm.call @free(%238) : (!llvm<"i8*">) -> ()
   %239 = llvm.extractvalue %25[0 : index] : !llvm<"{ double*, i64, [2 x i64], [2 x i64] }">
   %240 = llvm.bitcast %239 : !llvm<"double*"> to !llvm<"i8*">
   llvm.call @free(%240) : (!llvm<"i8*">) -> ()
   llvm.return
 }
 ```
 
+Even though not visible from the generated LLVM dialect, it must be noted that
+the conversion of the Memref dialect into the LLVM one does not produce calls
+to the `malloc` and `free` functions, but rather to the `_mlir_alloc` and
+`_mlir_free` functions. Their names have been intentionally kept different so
+that users can provide their own implementation by means of external libraries,
+thus allowing for different behaviour or profiling. For the sake of simplicity,
+this tutorial also includes  a transformation pass converting them back to the
+well known `malloc` and `free` functions, thus partially hiding this complexity
+to newcomers.
+
 See [Conversion to the LLVM IR Dialect](../../ConversionToLLVMDialect.md) for
 more in-depth details on lowering to the LLVM dialect.
 
 ## CodeGen: Getting Out of MLIR
 
 At this point we are right at the cusp of code generation. We can generate code
 in the LLVM dialect, so now we just need to export to LLVM IR and setup a JIT to
 run it.

mlir/examples/toy/Ch6/CMakeLists.txt

 
 set(LLVM_TARGET_DEFINITIONS mlir/ToyCombine.td)
 mlir_tablegen(ToyCombine.inc -gen-rewriters)
 add_public_tablegen_target(ToyCh6CombineIncGen)
 
 add_toy_chapter(toyc-ch6
   toyc.cpp
   parser/AST.cpp
+  mlir/AllocRenamingPass.cpp
   mlir/MLIRGen.cpp
   mlir/Dialect.cpp
   mlir/LowerToAffineLoops.cpp
   mlir/LowerToLLVM.cpp
   mlir/ShapeInferencePass.cpp
   mlir/ToyCombine.cpp
 
   DEPENDS

mlir/examples/toy/Ch6/include/toy/Passes.h

 /// Create a pass for lowering to operations in the `Affine` and `Std` dialects,
 /// for a subset of the Toy IR (e.g. matmul).
 std::unique_ptr<mlir::Pass> createLowerToAffinePass();
 
 /// Create a pass for lowering operations the remaining `Toy` operations, as
 /// well as `Affine` and `Std`, to the LLVM dialect for codegen.
 std::unique_ptr<mlir::Pass> createLowerToLLVMPass();
 
+/// Create a pass to rename the '_mlir_alloc' and '_mlir_free' functions to
+/// 'malloc' and 'free'.
+std::unique_ptr<mlir::Pass> createAllocRenamingPass();
+
 } // namespace toy
 } // namespace mlir
 
 #endif // TOY_PASSES_H

mlir/examples/toy/Ch6/mlir/AllocRenamingPass.cpp

+//====- AllocRenamingPass.cpp ---------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+//
+// This file implements the renaming of '_mlir_alloc' and '_mlir_free' functions
+// respectively into 'malloc' and 'free', so that the Toy example doesn't have
+// to deal with runtime libraries to be linked.
+//
+//===----------------------------------------------------------------------===//
+
+#include "toy/Passes.h"
+
+#include "mlir/Conversion/FuncToLLVM/ConvertFuncToLLVMPass.h"
+#include "mlir/Conversion/LLVMCommon/ConversionTarget.h"
+#include "mlir/Dialect/LLVMIR/LLVMDialect.h"
+#include "mlir/Pass/Pass.h"
+#include "mlir/Transforms/DialectConversion.h"
+#include "llvm/ADT/Sequence.h"
+
+using namespace mlir;
+
+//===----------------------------------------------------------------------===//
+// AllocRenamingPass RewritePatterns
+//===----------------------------------------------------------------------===//
+
+namespace {
+/// Rename the '_mlir_alloc' function into 'malloc'
+class AllocFuncRenamePattern : public OpRewritePattern<LLVM::LLVMFuncOp> {
+public:
+  using OpRewritePattern<LLVM::LLVMFuncOp>::OpRewritePattern;
+
+  LogicalResult match(LLVM::LLVMFuncOp op) const override {
+    return LogicalResult::success(op.getName() == "_mlir_alloc");
+  }
+
+  void rewrite(LLVM::LLVMFuncOp op, PatternRewriter &rewriter) const override {
+    rewriter.replaceOpWithNewOp<LLVM::LLVMFuncOp>(
+        op, "malloc", op.getFunctionType(), op.getLinkage());
+  }
+};
+
+/// Rename the '_mlir_free' function into 'free'
+class FreeFuncRenamePattern : public OpRewritePattern<LLVM::LLVMFuncOp> {
+public:
+  using OpRewritePattern<LLVM::LLVMFuncOp>::OpRewritePattern;
+
+  LogicalResult match(LLVM::LLVMFuncOp op) const override {
+    return LogicalResult::success(op.getName() == "_mlir_free");
+  }
+
+  void rewrite(LLVM::LLVMFuncOp op, PatternRewriter &rewriter) const override {
+    rewriter.replaceOpWithNewOp<LLVM::LLVMFuncOp>(
+        op, "free", op.getFunctionType(), op.getLinkage());
+  }
+};
+
+/// Rename the calls to '_mlir_alloc' with calls to 'malloc'
+class AllocCallRenamePattern : public OpRewritePattern<LLVM::CallOp> {
+public:
+  using OpRewritePattern<LLVM::CallOp>::OpRewritePattern;
+
+  LogicalResult match(LLVM::CallOp op) const override {
+    auto callee = op.getCallee();
+
+    if (!callee)
+      return failure();
+
+    return LogicalResult::success(*callee == "_mlir_alloc");
+  }
+
+  void rewrite(LLVM::CallOp op, PatternRewriter &rewriter) const override {
+    rewriter.replaceOpWithNewOp<LLVM::CallOp>(op, op.getResultTypes(), "malloc",
+                                              op.getOperands());
+  }
+};
+
+/// Rename the calls to '_mlir_free' with calls to 'free'
+class FreeCallRenamePattern : public OpRewritePattern<LLVM::CallOp> {
+public:
+  using OpRewritePattern<LLVM::CallOp>::OpRewritePattern;
+
+  LogicalResult match(LLVM::CallOp op) const override {
+    auto callee = op.getCallee();
+
+    if (!callee)
+      return failure();
+
+    return LogicalResult::success(*callee == "_mlir_free");
+  }
+
+  void rewrite(LLVM::CallOp op, PatternRewriter &rewriter) const override {
+    rewriter.replaceOpWithNewOp<LLVM::CallOp>(op, op.getResultTypes(), "free",
+                                              op.getOperands());
+  }
+};
+} // namespace
+
+//===----------------------------------------------------------------------===//
+// AllocRenamingPass
+//===----------------------------------------------------------------------===//
+
+namespace {
+struct AllocRenamingPass
+    : public PassWrapper<AllocRenamingPass, OperationPass<ModuleOp>> {
+  MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(AllocRenamingPass)
+
+  void getDependentDialects(DialectRegistry &registry) const override {
+    registry.insert<LLVM::LLVMDialect>();
+  }
+  void runOnOperation() final;
+};
+} // namespace
+
+void AllocRenamingPass::runOnOperation() {
+  LLVMConversionTarget target(getContext());
+
+  target.addDynamicallyLegalOp<LLVM::LLVMFuncOp>([](LLVM::LLVMFuncOp op) {
+    auto name = op.getName();
+    return name != "_mlir_alloc" && name != "_mlir_free";
+  });
+
+  target.addDynamicallyLegalOp<LLVM::CallOp>([](LLVM::CallOp op) {
+    auto callee = op.getCallee();
+
+    if (!callee)
+      return true;
+
+    return *callee != "_mlir_alloc" && *callee != "_mlir_free";
+  });
+
+  target.markUnknownOpDynamicallyLegal(
+      [](mlir::Operation *op) { return true; });
+
+  RewritePatternSet patterns(&getContext());
+
+  patterns.add<AllocFuncRenamePattern>(&getContext());
+  patterns.add<FreeFuncRenamePattern>(&getContext());
+  patterns.add<AllocCallRenamePattern>(&getContext());
+  patterns.add<FreeCallRenamePattern>(&getContext());
+
+  auto module = getOperation();
+  if (failed(applyFullConversion(module, target, std::move(patterns))))
+    signalPassFailure();
+}
+
+/// Create a pass to rename the '_mlir_alloc' and '_mlir_free' functions to
+/// 'malloc' and 'free'.
+std::unique_ptr<mlir::Pass> mlir::toy::createAllocRenamingPass() {
+  return std::make_unique<AllocRenamingPass>();
+}

mlir/examples/toy/Ch6/toyc.cpp

if (enableOpt) {
       optPM.addPass(mlir::createLoopFusionPass());
       optPM.addPass(mlir::createAffineScalarReplacementPass());
     }
   }
 
   if (isLoweringToLLVM) {
     // Finish lowering the toy IR to the LLVM dialect.
     pm.addPass(mlir::toy::createLowerToLLVMPass());
+    pm.addPass(mlir::toy::createAllocRenamingPass());
   }
 
   if (mlir::failed(pm.run(*module)))
     return 4;
   return 0;
 }
 
 int dumpAST() {
int runJit(mlir::ModuleOp module) {
 
   // Create an MLIR execution engine. The execution engine eagerly JIT-compiles
   // the module.
   mlir::ExecutionEngineOptions engineOptions;
   engineOptions.transformer = optPipeline;
   auto maybeEngine = mlir::ExecutionEngine::create(module, engineOptions);
   assert(maybeEngine && "failed to construct an execution engine");
   auto &engine = maybeEngine.get();
 
   // Invoke the JIT-compiled function.
   auto invocationResult = engine->invokePacked("main");
   if (invocationResult) {
     llvm::errs() << "JIT invocation failed\n";
     return -1;
   }
 
   return 0;

mlir/examples/toy/Ch7/CMakeLists.txt

 
 set(LLVM_TARGET_DEFINITIONS mlir/ToyCombine.td)
 mlir_tablegen(ToyCombine.inc -gen-rewriters)
 add_public_tablegen_target(ToyCh7CombineIncGen)
 
 add_toy_chapter(toyc-ch7
   toyc.cpp
   parser/AST.cpp
+  mlir/AllocRenamingPass.cpp
   mlir/MLIRGen.cpp
   mlir/Dialect.cpp
   mlir/LowerToAffineLoops.cpp
   mlir/LowerToLLVM.cpp
   mlir/ShapeInferencePass.cpp
   mlir/ToyCombine.cpp
 
   DEPENDS

mlir/examples/toy/Ch7/include/toy/Passes.h

 /// Create a pass for lowering to operations in the `Affine` and `Std` dialects,
 /// for a subset of the Toy IR (e.g. matmul).
 std::unique_ptr<mlir::Pass> createLowerToAffinePass();
 
 /// Create a pass for lowering operations the remaining `Toy` operations, as
 /// well as `Affine` and `Std`, to the LLVM dialect for codegen.
 std::unique_ptr<mlir::Pass> createLowerToLLVMPass();
 
+/// Create a pass to rename the '_mlir_alloc' and '_mlir_free' functions to
+/// 'malloc' and 'free'.
+std::unique_ptr<mlir::Pass> createAllocRenamingPass();
+
 } // namespace toy
 } // namespace mlir
 
 #endif // TOY_PASSES_H

mlir/examples/toy/Ch7/mlir/AllocRenamingPass.cpp

+//====- AllocRenamingPass.cpp ---------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+//
+// This file implements the renaming of '_mlir_alloc' and '_mlir_free' functions
+// respectively into 'malloc' and 'free', so that the Toy example doesn't have
+// to deal with runtime libraries to be linked.
+//
+//===----------------------------------------------------------------------===//
+
+#include "toy/Passes.h"
+
+#include "mlir/Conversion/FuncToLLVM/ConvertFuncToLLVMPass.h"
+#include "mlir/Conversion/LLVMCommon/ConversionTarget.h"
+#include "mlir/Dialect/LLVMIR/LLVMDialect.h"
+#include "mlir/Pass/Pass.h"
+#include "mlir/Transforms/DialectConversion.h"
+#include "llvm/ADT/Sequence.h"
+
+using namespace mlir;
+
+//===----------------------------------------------------------------------===//
+// AllocRenamingPass RewritePatterns
+//===----------------------------------------------------------------------===//
+
+namespace {
+/// Rename the '_mlir_alloc' function into 'malloc'
+class AllocFuncRenamePattern : public OpRewritePattern<LLVM::LLVMFuncOp> {
+public:
+  using OpRewritePattern<LLVM::LLVMFuncOp>::OpRewritePattern;
+
+  LogicalResult match(LLVM::LLVMFuncOp op) const override {
+    return LogicalResult::success(op.getName() == "_mlir_alloc");
+  }
+
+  void rewrite(LLVM::LLVMFuncOp op, PatternRewriter &rewriter) const override {
+    rewriter.replaceOpWithNewOp<LLVM::LLVMFuncOp>(
+        op, "malloc", op.getFunctionType(), op.getLinkage());
+  }
+};
+
+/// Rename the '_mlir_free' function into 'free'
+class FreeFuncRenamePattern : public OpRewritePattern<LLVM::LLVMFuncOp> {
+public:
+  using OpRewritePattern<LLVM::LLVMFuncOp>::OpRewritePattern;
+
+  LogicalResult match(LLVM::LLVMFuncOp op) const override {
+    return LogicalResult::success(op.getName() == "_mlir_free");
+  }
+
+  void rewrite(LLVM::LLVMFuncOp op, PatternRewriter &rewriter) const override {
+    rewriter.replaceOpWithNewOp<LLVM::LLVMFuncOp>(
+        op, "free", op.getFunctionType(), op.getLinkage());
+  }
+};
+
+/// Rename the calls to '_mlir_alloc' with calls to 'malloc'
+class AllocCallRenamePattern : public OpRewritePattern<LLVM::CallOp> {
+public:
+  using OpRewritePattern<LLVM::CallOp>::OpRewritePattern;
+
+  LogicalResult match(LLVM::CallOp op) const override {
+    auto callee = op.getCallee();
+
+    if (!callee)
+      return failure();
+
+    return LogicalResult::success(*callee == "_mlir_alloc");
+  }
+
+  void rewrite(LLVM::CallOp op, PatternRewriter &rewriter) const override {
+    rewriter.replaceOpWithNewOp<LLVM::CallOp>(op, op.getResultTypes(), "malloc",
+                                              op.getOperands());
+  }
+};
+
+/// Rename the calls to '_mlir_free' with calls to 'free'
+class FreeCallRenamePattern : public OpRewritePattern<LLVM::CallOp> {
+public:
+  using OpRewritePattern<LLVM::CallOp>::OpRewritePattern;
+
+  LogicalResult match(LLVM::CallOp op) const override {
+    auto callee = op.getCallee();
+
+    if (!callee)
+      return failure();
+
+    return LogicalResult::success(*callee == "_mlir_free");
+  }
+
+  void rewrite(LLVM::CallOp op, PatternRewriter &rewriter) const override {
+    rewriter.replaceOpWithNewOp<LLVM::CallOp>(op, op.getResultTypes(), "free",
+                                              op.getOperands());
+  }
+};
+} // namespace
+
+//===----------------------------------------------------------------------===//
+// AllocRenamingPass
+//===----------------------------------------------------------------------===//
+
+namespace {
+struct AllocRenamingPass
+    : public PassWrapper<AllocRenamingPass, OperationPass<ModuleOp>> {
+  MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(AllocRenamingPass)
+
+  void getDependentDialects(DialectRegistry &registry) const override {
+    registry.insert<LLVM::LLVMDialect>();
+  }
+  void runOnOperation() final;
+};
+} // namespace
+
+void AllocRenamingPass::runOnOperation() {
+  LLVMConversionTarget target(getContext());
+
+  target.addDynamicallyLegalOp<LLVM::LLVMFuncOp>([](LLVM::LLVMFuncOp op) {
+    auto name = op.getName();
+    return name != "_mlir_alloc" && name != "_mlir_free";
+  });
+
+  target.addDynamicallyLegalOp<LLVM::CallOp>([](LLVM::CallOp op) {
+    auto callee = op.getCallee();
+
+    if (!callee)
+      return true;
+
+    return *callee != "_mlir_alloc" && *callee != "_mlir_free";
+  });
+
+  target.markUnknownOpDynamicallyLegal(
+      [](mlir::Operation *op) { return true; });
+
+  RewritePatternSet patterns(&getContext());
+
+  patterns.add<AllocFuncRenamePattern>(&getContext());
+  patterns.add<FreeFuncRenamePattern>(&getContext());
+  patterns.add<AllocCallRenamePattern>(&getContext());
+  patterns.add<FreeCallRenamePattern>(&getContext());
+
+  auto module = getOperation();
+  if (failed(applyFullConversion(module, target, std::move(patterns))))
+    signalPassFailure();
+}
+
+/// Create a pass to rename the '_mlir_alloc' and '_mlir_free' functions to
+/// 'malloc' and 'free'.
+std::unique_ptr<mlir::Pass> mlir::toy::createAllocRenamingPass() {
+  return std::make_unique<AllocRenamingPass>();
+}

mlir/examples/toy/Ch7/toyc.cpp

if (enableOpt) {
       optPM.addPass(mlir::createLoopFusionPass());
       optPM.addPass(mlir::createAffineScalarReplacementPass());
     }
   }
 
   if (isLoweringToLLVM) {
     // Finish lowering the toy IR to the LLVM dialect.
     pm.addPass(mlir::toy::createLowerToLLVMPass());
+    pm.addPass(mlir::toy::createAllocRenamingPass());
   }
 
   if (mlir::failed(pm.run(*module)))
     return 4;
   return 0;
 }
 
 int dumpAST() {
int runJit(mlir::ModuleOp module) {
 
   // Create an MLIR execution engine. The execution engine eagerly JIT-compiles
   // the module.
   mlir::ExecutionEngineOptions engineOptions;
   engineOptions.transformer = optPipeline;
   auto maybeEngine = mlir::ExecutionEngine::create(module, engineOptions);
   assert(maybeEngine && "failed to construct an execution engine");
   auto &engine = maybeEngine.get();
 
   // Invoke the JIT-compiled function.
   auto invocationResult = engine->invokePacked("main");
   if (invocationResult) {
     llvm::errs() << "JIT invocation failed\n";
     return -1;
   }
 
   return 0;

mlir/include/mlir/Dialect/LLVMIR/FunctionCallUtils.h

 LLVM::LLVMFuncOp lookupOrCreatePrintOpenFn(ModuleOp moduleOp);
 LLVM::LLVMFuncOp lookupOrCreatePrintCloseFn(ModuleOp moduleOp);
 LLVM::LLVMFuncOp lookupOrCreatePrintCommaFn(ModuleOp moduleOp);
 LLVM::LLVMFuncOp lookupOrCreatePrintNewlineFn(ModuleOp moduleOp);
 LLVM::LLVMFuncOp lookupOrCreateMallocFn(ModuleOp moduleOp, Type indexType);
 LLVM::LLVMFuncOp lookupOrCreateAlignedAllocFn(ModuleOp moduleOp,
                                               Type indexType);
 LLVM::LLVMFuncOp lookupOrCreateFreeFn(ModuleOp moduleOp);
+LLVM::LLVMFuncOp lookupOrCreateAlignedFreeFn(ModuleOp moduleOp);
 LLVM::LLVMFuncOp lookupOrCreateMemRefCopyFn(ModuleOp moduleOp, Type indexType,
                                             Type unrankedDescriptorType);
 
 /// Create a FuncOp with signature `resultType`(`paramTypes`)` and name `name`.
 LLVM::LLVMFuncOp lookupOrCreateFn(ModuleOp moduleOp, StringRef name,
                                   ArrayRef<Type> paramTypes = {},
                                   Type resultType = {});
 

mlir/lib/Conversion/AsyncToLLVM/AsyncToLLVM.cpp

matchAndRewrite(CoroFreeOp op, OpAdaptor adaptor,
     auto loc = op->getLoc();
 
     // Get a pointer to the coroutine frame memory: @llvm.coro.free.
     auto coroMem =
         rewriter.create<LLVM::CoroFreeOp>(loc, i8Ptr, adaptor.getOperands());
 
     // Free the memory.
     auto freeFuncOp =
-        LLVM::lookupOrCreateFreeFn(op->getParentOfType<ModuleOp>());
+        LLVM::lookupOrCreateAlignedFreeFn(op->getParentOfType<ModuleOp>());
     rewriter.replaceOpWithNewOp<LLVM::CallOp>(op, TypeRange(),
                                               SymbolRefAttr::get(freeFuncOp),
                                               ValueRange(coroMem.getResult()));
 
     return success();
   }
 };
 } // namespace

mlir/lib/Conversion/MemRefToLLVM/MemRefToLLVM.cpp

Value casted = rewriter.create<LLVM::BitcastOp>(
         op.getLoc(), getVoidPtrType(),
         memref.allocatedPtr(rewriter, op.getLoc()));
     rewriter.replaceOpWithNewOp<LLVM::CallOp>(
         op, TypeRange(), SymbolRefAttr::get(freeFunc), casted);
     return success();
   }
 };
 
+struct AlignedDeallocOpLowering
+    : public ConvertOpToLLVMPattern<memref::DeallocOp> {
+  using ConvertOpToLLVMPattern<memref::DeallocOp>::ConvertOpToLLVMPattern;
+
+  explicit AlignedDeallocOpLowering(LLVMTypeConverter &converter)
+      : ConvertOpToLLVMPattern<memref::DeallocOp>(converter) {}
+
+  LogicalResult
+  matchAndRewrite(memref::DeallocOp op, OpAdaptor adaptor,
+                  ConversionPatternRewriter &rewriter) const override {
+    // Insert the `free` declaration if it is not already present.
+    auto freeFunc =
+        LLVM::lookupOrCreateAlignedFreeFn(op->getParentOfType<ModuleOp>());
+    MemRefDescriptor memref(adaptor.memref());
+    Value casted = rewriter.create<LLVM::BitcastOp>(
+        op.getLoc(), getVoidPtrType(),
+        memref.allocatedPtr(rewriter, op.getLoc()));
+    rewriter.replaceOpWithNewOp<LLVM::CallOp>(
+        op, TypeRange(), SymbolRefAttr::get(freeFunc), casted);
+    return success();
+  }
+};
+
 // A `dim` is converted to a constant for static sizes and to an access to the
 // size stored in the memref descriptor for dynamic sizes.
 struct DimOpLowering : public ConvertOpToLLVMPattern<memref::DimOp> {
   using ConvertOpToLLVMPattern<memref::DimOp>::ConvertOpToLLVMPattern;
 
   LogicalResult
   matchAndRewrite(memref::DimOp dimOp, OpAdaptor adaptor,
                   ConversionPatternRewriter &rewriter) const override {
patterns.add<
       ReassociatingReshapeOpConversion<memref::CollapseShapeOp>,
       StoreOpLowering,
       SubViewOpLowering,
       TransposeOpLowering,
       ViewOpLowering>(converter);
   // clang-format on
   auto allocLowering = converter.getOptions().allocLowering;
   if (allocLowering == LowerToLLVMOptions::AllocLowering::AlignedAlloc)
-    patterns.add<AlignedAllocOpLowering, DeallocOpLowering>(converter);
+    patterns.add<AlignedAllocOpLowering, AlignedDeallocOpLowering>(converter);
   else if (allocLowering == LowerToLLVMOptions::AllocLowering::Malloc)
     patterns.add<AllocOpLowering, DeallocOpLowering>(converter);
 }
 
 namespace {
 struct MemRefToLLVMPass : public ConvertMemRefToLLVMBase<MemRefToLLVMPass> {
   MemRefToLLVMPass() = default;
 

mlir/lib/Dialect/LLVMIR/IR/FunctionCallUtils.cpp

 static constexpr llvm::StringRef kPrintI64 = "printI64";
 static constexpr llvm::StringRef kPrintU64 = "printU64";
 static constexpr llvm::StringRef kPrintF32 = "printF32";
 static constexpr llvm::StringRef kPrintF64 = "printF64";
 static constexpr llvm::StringRef kPrintOpen = "printOpen";
 static constexpr llvm::StringRef kPrintClose = "printClose";
 static constexpr llvm::StringRef kPrintComma = "printComma";
 static constexpr llvm::StringRef kPrintNewline = "printNewline";
-static constexpr llvm::StringRef kMalloc = "malloc";
-static constexpr llvm::StringRef kAlignedAlloc = "aligned_alloc";
-static constexpr llvm::StringRef kFree = "free";
+static constexpr llvm::StringRef kMalloc = "_mlir_alloc";
+static constexpr llvm::StringRef kAlignedAlloc = "_mlir_aligned_alloc";
+static constexpr llvm::StringRef kFree = "_mlir_free";
+static constexpr llvm::StringRef kAlignedFree = "_mlir_aligned_free";
 static constexpr llvm::StringRef kMemRefCopy = "memrefCopy";
 
 /// Generic print function lookupOrCreate helper.
 LLVM::LLVMFuncOp mlir::LLVM::lookupOrCreateFn(ModuleOp moduleOp, StringRef name,
                                               ArrayRef<Type> paramTypes,
                                               Type resultType) {
   auto func = moduleOp.lookupSymbol<LLVM::LLVMFuncOp>(name);
   if (func)

 
 LLVM::LLVMFuncOp mlir::LLVM::lookupOrCreateFreeFn(ModuleOp moduleOp) {
   return LLVM::lookupOrCreateFn(
       moduleOp, kFree,
       LLVM::LLVMPointerType::get(IntegerType::get(moduleOp->getContext(), 8)),
       LLVM::LLVMVoidType::get(moduleOp->getContext()));
 }
 
+LLVM::LLVMFuncOp mlir::LLVM::lookupOrCreateAlignedFreeFn(ModuleOp moduleOp) {
+  return LLVM::lookupOrCreateFn(
+      moduleOp, kAlignedFree,
+      LLVM::LLVMPointerType::get(IntegerType::get(moduleOp->getContext(), 8)),
+      LLVM::LLVMVoidType::get(moduleOp->getContext()));
+}
+
 LLVM::LLVMFuncOp
 mlir::LLVM::lookupOrCreateMemRefCopyFn(ModuleOp moduleOp, Type indexType,
                                        Type unrankedDescriptorType) {
   return LLVM::lookupOrCreateFn(
       moduleOp, kMemRefCopy,
       ArrayRef<Type>{indexType, unrankedDescriptorType, unrankedDescriptorType},
       LLVM::LLVMVoidType::get(moduleOp->getContext()));
 }

mlir/lib/ExecutionEngine/RunnerUtils.cpp

 // C++ runtime. These may be progressively migrated to CRunnerUtils.cpp over
 // time.
 //
 //===----------------------------------------------------------------------===//
 
 #include "mlir/ExecutionEngine/RunnerUtils.h"
 #include <chrono>
 
+#ifdef _MSC_VER
+#include "malloc.h"
+#endif
+
 // NOLINTBEGIN(*-identifier-naming)
 
+extern "C" void *_mlir_alloc(uint64_t size) { return malloc(size); }
+
+extern "C" void *_mlir_aligned_alloc(uint64_t alignment, uint64_t size) {
+#ifdef _MSC_VER
+  return _aligned_malloc(size, alignment);
+#else
+  return aligned_alloc(alignment, size);
+#endif
+}
+
+extern "C" void _mlir_free(void *ptr) { free(ptr); }
+
+extern "C" void _mlir_aligned_free(void *ptr) {
+#ifdef _MSC_VER
+  _aligned_free(ptr);
+#else
+  free(ptr);
+#endif
+}
+
 extern "C" void _mlir_ciface_printMemrefShapeI8(UnrankedMemRefType<int8_t> *M) {
   std::cout << "Unranked Memref ";
   printMemRefMetaData(std::cout, DynamicMemRefType<int8_t>(*M));
   std::cout << "\n";
 }
 
 extern "C" void
 _mlir_ciface_printMemrefShapeI32(UnrankedMemRefType<int32_t> *M) {

mlir/lib/Target/LLVMIR/ModuleTranslation.cpp

if (auto dataLayoutAttr =
     if (failed(llvmDataLayout))
       return nullptr;
     llvmModule->setDataLayout(*llvmDataLayout);
   }
   if (auto targetTripleAttr =
           m->getAttr(LLVM::LLVMDialect::getTargetTripleAttrName()))
     llvmModule->setTargetTriple(targetTripleAttr.cast<StringAttr>().getValue());
 
-  // Inject declarations for `malloc` and `free` functions that can be used in
-  // memref allocation/deallocation coming from standard ops lowering.
+  // Inject declarations for `_mlir_alloc`, `_mlir_aligned_alloc` and
+  // `_mlir_free` functions that can be used in memref allocation / deallocation
+  // coming from standard ops lowering.
   llvm::IRBuilder<> builder(llvmContext);
-  llvmModule->getOrInsertFunction("malloc", builder.getInt8PtrTy(),
+  llvmModule->getOrInsertFunction("_mlir_alloc", builder.getInt8PtrTy(),
                                   builder.getInt64Ty());
-  llvmModule->getOrInsertFunction("free", builder.getVoidTy(),
+  llvmModule->getOrInsertFunction("_mlir_aligned_alloc", builder.getInt8PtrTy(),
+                                  builder.getInt64Ty(), builder.getInt64Ty());
+  llvmModule->getOrInsertFunction("_mlir_free", builder.getVoidTy(),
+                                  builder.getInt8PtrTy());
+  llvmModule->getOrInsertFunction("_mlir_aligned_free", builder.getVoidTy(),
                                   builder.getInt8PtrTy());
 
   return llvmModule;
 }
 
 std::unique_ptr<llvm::Module>
 mlir::translateModuleToLLVMIR(Operation *module, llvm::LLVMContext &llvmContext,
                               StringRef name) {

mlir/test/Conversion/AsyncToLLVM/convert-coro-to-llvm.mlir

func.func @coro_begin() {
   // CHECK: %[[SIZE:.*]] = llvm.intr.coro.size : i64
   // CHECK: %[[ALIGN:.*]] = llvm.intr.coro.align : i64
   // CHECK: %[[SIZE_PLUS_ALIGN:.*]] = llvm.add %[[SIZE]], %[[ALIGN]] : i64
   // CHECK: %[[C1:.*]] = llvm.mlir.constant(1 : i64) : i64
   // CHECK: %[[SIZE_PLUS_ALIGN_MINUS_ONE:.*]] = llvm.sub %[[SIZE_PLUS_ALIGN]], %[[C1]] : i64
   // CHECK: %[[C0:.*]] = llvm.mlir.constant(0 : i64) : i64
   // CHECK: %[[NEGATED_ALIGN:.*]] = llvm.sub %[[C0]], %[[ALIGN]]  : i64
   // CHECK: %[[ROUNDED_SIZE:.*]] = llvm.and %[[SIZE_PLUS_ALIGN_MINUS_ONE]], %[[NEGATED_ALIGN]] : i64
-  // CHECK: %[[ALLOC:.*]] = llvm.call @aligned_alloc(%[[ALIGN]], %[[ROUNDED_SIZE]])
+  // CHECK: %[[ALLOC:.*]] = llvm.call @_mlir_aligned_alloc(%[[ALIGN]], %[[ROUNDED_SIZE]])
   // CHECK: %[[HDL:.*]] = llvm.intr.coro.begin %[[ID]], %[[ALLOC]]
   %1 = async.coro.begin %0
   return
 }
 
 // CHECK-LABEL: @coro_free
 func.func @coro_free() {
   // CHECK: %[[ID:.*]] = llvm.intr.coro.id
   %0 = async.coro.id
   // CHECK: %[[HDL:.*]] = llvm.intr.coro.begin
   %1 = async.coro.begin %0
   // CHECK: %[[MEM:.*]] = llvm.intr.coro.free %[[ID]], %[[HDL]]
-  // CHECK: llvm.call @free(%[[MEM]])
+  // CHECK: llvm.call @_mlir_aligned_free(%[[MEM]])
   async.coro.free %0, %1
   return
 }
 
 // CHECK-LABEL: @coro_end
 func.func @coro_end() {
   %0 = async.coro.id
   // CHECK: %[[HDL:.*]] = llvm.intr.coro.begin

mlir/test/Conversion/AsyncToLLVM/convert-to-llvm.mlir

 // Resume coroutine after suspension.
 // CHECK: ^[[RESUME]]:
 // CHECK: memref.store %arg0, %arg1[%c0] : memref<1xf32>
 // CHECK: call @mlirAsyncRuntimeEmplaceToken(%[[RET]])
 
 // Delete coroutine.
 // CHECK: ^[[CLEANUP]]:
 // CHECK: %[[MEM:.*]] = llvm.intr.coro.free
-// CHECK: llvm.call @free(%[[MEM]])
+// CHECK: llvm.call @_mlir_aligned_free(%[[MEM]])
 
 // Suspend coroutine, and also a return statement for ramp function.
 // CHECK: ^[[SUSPEND]]:
 // CHECK: llvm.intr.coro.end
 // CHECK: return %[[RET]]
 
 // -----
 

mlir/test/Conversion/FuncToLLVM/calling-convention.mlir

func.func @return_var_memref_caller(%arg0: memref<4x3xf32>) {
   // CHECK: %[[DOUBLE_RANK:.*]] = llvm.mul %[[TWO]], %[[RANK]]
   // CHECK: %[[DOUBLE_RANK_INC:.*]] = llvm.add %[[DOUBLE_RANK]], %[[ONE]]
   // CHECK: %[[TABLES_SIZE:.*]] = llvm.mul %[[DOUBLE_RANK_INC]], %[[IDX_SIZE]]
   // CHECK: %[[ALLOC_SIZE:.*]] = llvm.add %[[DOUBLE_PTR_SIZE]], %[[TABLES_SIZE]]
   // CHECK: %[[FALSE:.*]] = llvm.mlir.constant(false)
   // CHECK: %[[ALLOCA:.*]] = llvm.alloca %[[ALLOC_SIZE]] x i8
   // CHECK: %[[SOURCE:.*]] = llvm.extractvalue %[[CALL_RES]][1]
   // CHECK: "llvm.intr.memcpy"(%[[ALLOCA]], %[[SOURCE]], %[[ALLOC_SIZE]], %[[FALSE]])
-  // CHECK: llvm.call @free(%[[SOURCE]])
+  // CHECK: llvm.call @_mlir_free(%[[SOURCE]])
   // CHECK: %[[DESC:.*]] = llvm.mlir.undef : !llvm.struct<(i64, ptr<i8>)>
   // CHECK: %[[RANK:.*]] = llvm.extractvalue %[[CALL_RES]][0] : !llvm.struct<(i64, ptr<i8>)>
   // CHECK: %[[DESC_1:.*]] = llvm.insertvalue %[[RANK]], %[[DESC]][0]
   // CHECK: llvm.insertvalue %[[ALLOCA]], %[[DESC_1]][1]
   return
 }
 
 // CHECK-LABEL: llvm.func @return_var_memref
func.func @return_var_memref(%arg0: memref<4x3xf32>) -> memref<*xf32> attributes { llvm.emit_c_interface } {
   // CHECK: %[[IDX_SIZE:.*]] = llvm.mlir.constant
 
   // CHECK: %[[DOUBLE_PTR_SIZE:.*]] = llvm.mul %[[TWO]], %[[PTR_SIZE]]
   // CHECK: %[[DOUBLE_RANK:.*]] = llvm.mul %[[TWO]], %[[RANK]]
   // CHECK: %[[DOUBLE_RANK_INC:.*]] = llvm.add %[[DOUBLE_RANK]], %[[ONE]]
   // CHECK: %[[TABLES_SIZE:.*]] = llvm.mul %[[DOUBLE_RANK_INC]], %[[IDX_SIZE]]
   // CHECK: %[[ALLOC_SIZE:.*]] = llvm.add %[[DOUBLE_PTR_SIZE]], %[[TABLES_SIZE]]
   // CHECK: %[[FALSE:.*]] = llvm.mlir.constant(false)
-  // CHECK: %[[ALLOCATED:.*]] = llvm.call @malloc(%[[ALLOC_SIZE]])
+  // CHECK: %[[ALLOCATED:.*]] = llvm.call @_mlir_alloc(%[[ALLOC_SIZE]])
   // CHECK: "llvm.intr.memcpy"(%[[ALLOCATED]], %[[MEMORY]], %[[ALLOC_SIZE]], %[[FALSE]])
   // CHECK: %[[NEW_DESC:.*]] = llvm.mlir.undef : !llvm.struct<(i64, ptr<i8>)>
   // CHECK: %[[NEW_DESC_1:.*]] = llvm.insertvalue %[[RANK]], %[[NEW_DESC]][0]
   // CHECK: %[[NEW_DESC_2:.*]] = llvm.insertvalue %[[ALLOCATED]], %[[NEW_DESC_1]][1]
   // CHECK: llvm.return %[[NEW_DESC_2]]
   return %0 : memref<*xf32>
 }
 
func.func @return_two_var_memref_caller(%arg0: memref<4x3xf32>) {
   // CHECK: %[[CALL_RES:.*]] = llvm.call @return_two_var_memref
   // CHECK: %[[RES_1:.*]] = llvm.extractvalue %[[CALL_RES]][0]
   // CHECK: %[[RES_2:.*]] = llvm.extractvalue %[[CALL_RES]][1]
   %0:2 = call @return_two_var_memref(%arg0) : (memref<4x3xf32>) -> (memref<*xf32>, memref<*xf32>)
 
   // CHECK: %[[ALLOCA_1:.*]] = llvm.alloca %{{.*}} x i8
   // CHECK: %[[SOURCE_1:.*]] = llvm.extractvalue %[[RES_1:.*]][1] : ![[DESC_TYPE:.*]]
   // CHECK: "llvm.intr.memcpy"(%[[ALLOCA_1]], %[[SOURCE_1]], %{{.*}}, %[[FALSE:.*]])
-  // CHECK: llvm.call @free(%[[SOURCE_1]])
+  // CHECK: llvm.call @_mlir_free(%[[SOURCE_1]])
   // CHECK: %[[DESC_1:.*]] = llvm.mlir.undef : ![[DESC_TYPE]]
   // CHECK: %[[DESC_11:.*]] = llvm.insertvalue %{{.*}}, %[[DESC_1]][0]
   // CHECK: llvm.insertvalue %[[ALLOCA_1]], %[[DESC_11]][1]
 
   // CHECK: %[[ALLOCA_2:.*]] = llvm.alloca %{{.*}} x i8
   // CHECK: %[[SOURCE_2:.*]] = llvm.extractvalue %[[RES_2:.*]][1]
   // CHECK: "llvm.intr.memcpy"(%[[ALLOCA_2]], %[[SOURCE_2]], %{{.*}}, %[[FALSE]])
-  // CHECK: llvm.call @free(%[[SOURCE_2]])
+  // CHECK: llvm.call @_mlir_free(%[[SOURCE_2]])
   // CHECK: %[[DESC_2:.*]] = llvm.mlir.undef : ![[DESC_TYPE]]
   // CHECK: %[[DESC_21:.*]] = llvm.insertvalue %{{.*}}, %[[DESC_2]][0]
   // CHECK: llvm.insertvalue %[[ALLOCA_2]], %[[DESC_21]][1]
   return
 }
 
 // CHECK-LABEL: llvm.func @return_two_var_memref
 func.func @return_two_var_memref(%arg0: memref<4x3xf32>) -> (memref<*xf32>, memref<*xf32>) attributes { llvm.emit_c_interface } {
   // Match the construction of the unranked descriptor.
   // CHECK: %[[ALLOCA:.*]] = llvm.alloca
   // CHECK: %[[MEMORY:.*]] = llvm.bitcast %[[ALLOCA]]
   // CHECK: %[[DESC_0:.*]] = llvm.mlir.undef : !llvm.struct<(i64, ptr<i8>)>
   // CHECK: %[[DESC_1:.*]] = llvm.insertvalue %{{.*}}, %[[DESC_0]][0]
   // CHECK: %[[DESC_2:.*]] = llvm.insertvalue %[[MEMORY]], %[[DESC_1]][1]
   %0 = memref.cast %arg0 : memref<4x3xf32> to memref<*xf32>
 
   // Only check that we allocate the memory for each operand of the "return"
   // separately, even if both operands are the same value. The calling
   // convention requires the caller to free them and the caller cannot know
   // whether they are the same value or not.
-  // CHECK: %[[ALLOCATED_1:.*]] = llvm.call @malloc(%{{.*}})
+  // CHECK: %[[ALLOCATED_1:.*]] = llvm.call @_mlir_alloc(%{{.*}})
   // CHECK: "llvm.intr.memcpy"(%[[ALLOCATED_1]], %[[MEMORY]], %{{.*}}, %[[FALSE:.*]])
   // CHECK: %[[RES_1:.*]] = llvm.mlir.undef
   // CHECK: %[[RES_11:.*]] = llvm.insertvalue %{{.*}}, %[[RES_1]][0]
   // CHECK: %[[RES_12:.*]] = llvm.insertvalue %[[ALLOCATED_1]], %[[RES_11]][1]
 
-  // CHECK: %[[ALLOCATED_2:.*]] = llvm.call @malloc(%{{.*}})
+  // CHECK: %[[ALLOCATED_2:.*]] = llvm.call @_mlir_alloc(%{{.*}})
   // CHECK: "llvm.intr.memcpy"(%[[ALLOCATED_2]], %[[MEMORY]], %{{.*}}, %[[FALSE]])
   // CHECK: %[[RES_2:.*]] = llvm.mlir.undef
   // CHECK: %[[RES_21:.*]] = llvm.insertvalue %{{.*}}, %[[RES_2]][0]
   // CHECK: %[[RES_22:.*]] = llvm.insertvalue %[[ALLOCATED_2]], %[[RES_21]][1]
 
   // CHECK: %[[RESULTS:.*]] = llvm.mlir.undef : !llvm.struct<(struct<(i64, ptr<i8>)>, struct<(i64, ptr<i8>)>)>
   // CHECK: %[[RESULTS_1:.*]] = llvm.insertvalue %[[RES_12]], %[[RESULTS]]
   // CHECK: %[[RESULTS_2:.*]] = llvm.insertvalue %[[RES_22]], %[[RESULTS_1]]

mlir/test/Conversion/MemRefToLLVM/convert-dynamic-memref-ops.mlir

 // RUN: mlir-opt -split-input-file -convert-memref-to-llvm %s | FileCheck %s
 // RUN: mlir-opt -split-input-file -convert-memref-to-llvm='use-aligned-alloc=1' %s | FileCheck %s --check-prefix=ALIGNED-ALLOC
 // RUN: mlir-opt -split-input-file -convert-memref-to-llvm='index-bitwidth=32' %s | FileCheck --check-prefix=CHECK32 %s
 
 // CHECK-LABEL: func @mixed_alloc(
 //       CHECK:   %[[Marg:.*]]: index, %[[Narg:.*]]: index)
 func.func @mixed_alloc(%arg0: index, %arg1: index) -> memref<?x42x?xf32> {
 //   CHECK-DAG:  %[[M:.*]] = builtin.unrealized_conversion_cast %[[Marg]]
 //   CHECK-DAG:  %[[N:.*]] = builtin.unrealized_conversion_cast %[[Narg]]
 //       CHECK:  %[[c42:.*]] = llvm.mlir.constant(42 : index) : i64
 //  CHECK-NEXT:  %[[one:.*]] = llvm.mlir.constant(1 : index) : i64
 //  CHECK-NEXT:  %[[st0:.*]] = llvm.mul %[[N]], %[[c42]] : i64
 //  CHECK-NEXT:  %[[sz:.*]] = llvm.mul %[[st0]], %[[M]] : i64
 //  CHECK-NEXT:  %[[null:.*]] = llvm.mlir.null : !llvm.ptr<f32>
 //  CHECK-NEXT:  %[[gep:.*]] = llvm.getelementptr %[[null]][%[[sz]]] : (!llvm.ptr<f32>, i64) -> !llvm.ptr<f32>
 //  CHECK-NEXT:  %[[sz_bytes:.*]] = llvm.ptrtoint %[[gep]] : !llvm.ptr<f32> to i64
-//  CHECK-NEXT:  llvm.call @malloc(%[[sz_bytes]]) : (i64) -> !llvm.ptr<i8>
+//  CHECK-NEXT:  llvm.call @_mlir_alloc(%[[sz_bytes]]) : (i64) -> !llvm.ptr<i8>
 //  CHECK-NEXT:  llvm.bitcast %{{.*}} : !llvm.ptr<i8> to !llvm.ptr<f32>
 //  CHECK-NEXT:  llvm.mlir.undef : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<3 x i64>, array<3 x i64>)>
 //  CHECK-NEXT:  llvm.insertvalue %{{.*}}, %{{.*}}[0] : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<3 x i64>, array<3 x i64>)>
 //  CHECK-NEXT:  llvm.insertvalue %{{.*}}, %{{.*}}[1] : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<3 x i64>, array<3 x i64>)>
 //  CHECK-NEXT:  %[[off:.*]] = llvm.mlir.constant(0 : index) : i64
 //  CHECK-NEXT:  llvm.insertvalue %[[off]], %{{.*}}[2] : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<3 x i64>, array<3 x i64>)>
 //  CHECK-NEXT:  llvm.insertvalue %[[M]], %{{.*}}[3, 0] : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<3 x i64>, array<3 x i64>)>
 //  CHECK-NEXT:  llvm.insertvalue %[[c42]], %{{.*}}[3, 1] : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<3 x i64>, array<3 x i64>)>
 //  CHECK-NEXT:  llvm.insertvalue %[[N]], %{{.*}}[3, 2] : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<3 x i64>, array<3 x i64>)>
 //  CHECK-NEXT:  llvm.insertvalue %[[st0]], %{{.*}}[4, 0] : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<3 x i64>, array<3 x i64>)>
 //  CHECK-NEXT:  llvm.insertvalue %[[N]], %{{.*}}[4, 1] : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<3 x i64>, array<3 x i64>)>
 //  CHECK-NEXT:  llvm.insertvalue %[[one]], %{{.*}}[4, 2] : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<3 x i64>, array<3 x i64>)>
   %0 = memref.alloc(%arg0, %arg1) : memref<?x42x?xf32>
   return %0 : memref<?x42x?xf32>
 }
 
 // -----
 
 // CHECK-LABEL: func @mixed_dealloc
 func.func @mixed_dealloc(%arg0: memref<?x42x?xf32>) {
 //      CHECK:  %[[ptr:.*]] = llvm.extractvalue %{{.*}}[0] : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<3 x i64>, array<3 x i64>)>
 // CHECK-NEXT:  %[[ptri8:.*]] = llvm.bitcast %[[ptr]] : !llvm.ptr<f32> to !llvm.ptr<i8>
-// CHECK-NEXT:  llvm.call @free(%[[ptri8]]) : (!llvm.ptr<i8>) -> ()
+// CHECK-NEXT:  llvm.call @_mlir_free(%[[ptri8]]) : (!llvm.ptr<i8>) -> ()
   memref.dealloc %arg0 : memref<?x42x?xf32>
   return
 }
 
 // -----
 
 // CHECK-LABEL: func @dynamic_alloc(
 //       CHECK:   %[[Marg:.*]]: index, %[[Narg:.*]]: index)
 func.func @dynamic_alloc(%arg0: index, %arg1: index) -> memref<?x?xf32> {
 //   CHECK-DAG:  %[[M:.*]] = builtin.unrealized_conversion_cast %[[Marg]]
 //   CHECK-DAG:  %[[N:.*]] = builtin.unrealized_conversion_cast %[[Narg]]
 //  CHECK-NEXT:  %[[one:.*]] = llvm.mlir.constant(1 : index) : i64
 //  CHECK-NEXT:  %[[sz:.*]] = llvm.mul %[[N]], %[[M]] : i64
 //  CHECK-NEXT:  %[[null:.*]] = llvm.mlir.null : !llvm.ptr<f32>
 //  CHECK-NEXT:  %[[gep:.*]] = llvm.getelementptr %[[null]][%[[sz]]] : (!llvm.ptr<f32>, i64) -> !llvm.ptr<f32>
 //  CHECK-NEXT:  %[[sz_bytes:.*]] = llvm.ptrtoint %[[gep]] : !llvm.ptr<f32> to i64
-//  CHECK-NEXT:  llvm.call @malloc(%[[sz_bytes]]) : (i64) -> !llvm.ptr<i8>
+//  CHECK-NEXT:  llvm.call @_mlir_alloc(%[[sz_bytes]]) : (i64) -> !llvm.ptr<i8>
 //  CHECK-NEXT:  llvm.bitcast %{{.*}} : !llvm.ptr<i8> to !llvm.ptr<f32>
 //  CHECK-NEXT:  llvm.mlir.undef : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<2 x i64>, array<2 x i64>)>
 //  CHECK-NEXT:  llvm.insertvalue %{{.*}}, %{{.*}}[0] : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<2 x i64>, array<2 x i64>)>
 //  CHECK-NEXT:  llvm.insertvalue %{{.*}}, %{{.*}}[1] : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<2 x i64>, array<2 x i64>)>
 //  CHECK-NEXT:  %[[off:.*]] = llvm.mlir.constant(0 : index) : i64
 //  CHECK-NEXT:  llvm.insertvalue %[[off]], %{{.*}}[2] : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<2 x i64>, array<2 x i64>)>
 //  CHECK-NEXT:  llvm.insertvalue %[[M]], %{{.*}}[3, 0] : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<2 x i64>, array<2 x i64>)>
 //  CHECK-NEXT:  llvm.insertvalue %[[N]], %{{.*}}[3, 1] : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<2 x i64>, array<2 x i64>)>

 }
 
 // -----
 
 // CHECK-LABEL: func @dynamic_dealloc
 func.func @dynamic_dealloc(%arg0: memref<?x?xf32>) {
 //      CHECK:  %[[ptr:.*]] = llvm.extractvalue %{{.*}}[0] : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<2 x i64>, array<2 x i64>)>
 // CHECK-NEXT:  %[[ptri8:.*]] = llvm.bitcast %[[ptr]] : !llvm.ptr<f32> to !llvm.ptr<i8>
-// CHECK-NEXT:  llvm.call @free(%[[ptri8]]) : (!llvm.ptr<i8>) -> ()
+// CHECK-NEXT:  llvm.call @_mlir_free(%[[ptri8]]) : (!llvm.ptr<i8>) -> ()
   memref.dealloc %arg0 : memref<?x?xf32>
   return
 }
 
 // -----
 
 // CHECK-LABEL: func @stdlib_aligned_alloc({{.*}})
 // ALIGNED-ALLOC-LABEL: func @stdlib_aligned_alloc({{.*}})
 func.func @stdlib_aligned_alloc(%N : index) -> memref<32x18xf32> {
 // ALIGNED-ALLOC:       %[[sz1:.*]] = llvm.mlir.constant(32 : index) : i64
 // ALIGNED-ALLOC-NEXT:  %[[sz2:.*]] = llvm.mlir.constant(18 : index) : i64
 // ALIGNED-ALLOC-NEXT:  %[[one:.*]] = llvm.mlir.constant(1 : index) : i64
 // ALIGNED-ALLOC-NEXT:  %[[num_elems:.*]] = llvm.mlir.constant(576 : index) : i64
 // ALIGNED-ALLOC-NEXT:  %[[null:.*]] = llvm.mlir.null : !llvm.ptr<f32>
 // ALIGNED-ALLOC-NEXT:  %[[gep:.*]] = llvm.getelementptr %[[null]][%[[num_elems]]] : (!llvm.ptr<f32>, i64) -> !llvm.ptr<f32>
 // ALIGNED-ALLOC-NEXT:  %[[bytes:.*]] = llvm.ptrtoint %[[gep]] : !llvm.ptr<f32> to i64
 // ALIGNED-ALLOC-NEXT:  %[[alignment:.*]] = llvm.mlir.constant(32 : index) : i64
-// ALIGNED-ALLOC-NEXT:  %[[allocated:.*]] = llvm.call @aligned_alloc(%[[alignment]], %[[bytes]]) : (i64, i64) -> !llvm.ptr<i8>
+// ALIGNED-ALLOC-NEXT:  %[[allocated:.*]] = llvm.call @_mlir_aligned_alloc(%[[alignment]], %[[bytes]]) : (i64, i64) -> !llvm.ptr<i8>
 // ALIGNED-ALLOC-NEXT:  llvm.bitcast %[[allocated]] : !llvm.ptr<i8> to !llvm.ptr<f32>
   %0 = memref.alloc() {alignment = 32} : memref<32x18xf32>
   // Do another alloc just to test that we have a unique declaration for
   // aligned_alloc.
-  // ALIGNED-ALLOC:  llvm.call @aligned_alloc
+  // ALIGNED-ALLOC:  llvm.call @_mlir_aligned_alloc
   %1 = memref.alloc() {alignment = 64} : memref<4096xf32>
 
   // Alignment is to element type boundaries (minimum 16 bytes).
   // ALIGNED-ALLOC:  %[[c32:.*]] = llvm.mlir.constant(32 : index) : i64
-  // ALIGNED-ALLOC-NEXT:  llvm.call @aligned_alloc(%[[c32]]
+  // ALIGNED-ALLOC-NEXT:  llvm.call @_mlir_aligned_alloc(%[[c32]]
   %2 = memref.alloc() : memref<4096xvector<8xf32>>
   // The minimum alignment is 16 bytes unless explicitly specified.
   // ALIGNED-ALLOC:  %[[c16:.*]] = llvm.mlir.constant(16 : index) : i64
-  // ALIGNED-ALLOC-NEXT:  llvm.call @aligned_alloc(%[[c16]],
+  // ALIGNED-ALLOC-NEXT:  llvm.call @_mlir_aligned_alloc(%[[c16]],
   %3 = memref.alloc() : memref<4096xvector<2xf32>>
   // ALIGNED-ALLOC:  %[[c8:.*]] = llvm.mlir.constant(8 : index) : i64
-  // ALIGNED-ALLOC-NEXT:  llvm.call @aligned_alloc(%[[c8]],
+  // ALIGNED-ALLOC-NEXT:  llvm.call @_mlir_aligned_alloc(%[[c8]],
   %4 = memref.alloc() {alignment = 8} : memref<1024xvector<4xf32>>
   // Bump the memref allocation size if its size is not a multiple of alignment.
   // ALIGNED-ALLOC:       %[[c32:.*]] = llvm.mlir.constant(32 : index) : i64
   // ALIGNED-ALLOC:       llvm.mlir.constant(1 : index) : i64
   // ALIGNED-ALLOC-NEXT:  llvm.sub
   // ALIGNED-ALLOC-NEXT:  llvm.add
   // ALIGNED-ALLOC-NEXT:  llvm.urem
   // ALIGNED-ALLOC-NEXT:  %[[SIZE_ALIGNED:.*]] = llvm.sub
-  // ALIGNED-ALLOC-NEXT:  llvm.call @aligned_alloc(%[[c32]], %[[SIZE_ALIGNED]])
+  // ALIGNED-ALLOC-NEXT:  llvm.call @_mlir_aligned_alloc(%[[c32]], %[[SIZE_ALIGNED]])
   %5 = memref.alloc() {alignment = 32} : memref<100xf32>
   // Bump alignment to the next power of two if it isn't.
   // ALIGNED-ALLOC:  %[[c128:.*]] = llvm.mlir.constant(128 : index) : i64
-  // ALIGNED-ALLOC:  llvm.call @aligned_alloc(%[[c128]]
+  // ALIGNED-ALLOC:  llvm.call @_mlir_aligned_alloc(%[[c128]]
   %6 = memref.alloc(%N) : memref<?xvector<18xf32>>
   return %0 : memref<32x18xf32>
 }
 
 // -----
 
 // CHECK-LABEL: func @mixed_load(
 // CHECK:         %{{.*}}, %[[Iarg:.*]]: index, %[[Jarg:.*]]: index)
func.func @memref_of_memref() {
   // ALIGNED-ALLOC: %[[PTR:.*]] = llvm.getelementptr
   // ALIGNED-ALLOC: %[[SIZEOF:.*]] = llvm.ptrtoint
 
   // Static alignment should be computed as ceilPowerOf2(2 * sizeof(pointer) +
   // (1 + 2 * rank) * sizeof(index) = ceilPowerOf2(2 * 8 + 3 * 8) = 64.
   // ALIGNED-ALLOC: llvm.mlir.constant(64 : index)
 
   // Check that the types are converted as expected.
-  // ALIGNED-ALLOC: llvm.call @aligned_alloc
+  // ALIGNED-ALLOC: llvm.call @_mlir_aligned_alloc
   // ALIGNED-ALLOC: llvm.bitcast %{{.*}} : !llvm.ptr<i8> to
   // ALIGNED-ALLOC-SAME: !llvm.
   // ALIGNED-ALLOC-SAME: [[INNER:ptr<struct<\(ptr<f32>, ptr<f32>, i64, array<1 x i64>, array<1 x i64>\)>>]]
   // ALIGNED-ALLOC: llvm.mlir.undef
   // ALIGNED-ALLOC-SAME: !llvm.struct<([[INNER]], [[INNER]], i64, array<1 x i64>, array<1 x i64>)>
   %0 = memref.alloc() : memref<1xmemref<1xf32>>
   return
 }
 
 // -----
 
 module attributes { dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry<index, 32>> } {
   // ALIGNED-ALLOC-LABEL: @memref_of_memref_32
   func.func @memref_of_memref_32() {
     // Sizeof computation is as usual.
     // ALIGNED-ALLOC: %[[NULL:.*]] = llvm.mlir.null
     // ALIGNED-ALLOC: %[[PTR:.*]] = llvm.getelementptr
     // ALIGNED-ALLOC: %[[SIZEOF:.*]] = llvm.ptrtoint
 
     // Static alignment should be computed as ceilPowerOf2(2 * sizeof(pointer) +
     // (1 + 2 * rank) * sizeof(index) = ceilPowerOf2(2 * 8 + 3 * 4) = 32.
     // ALIGNED-ALLOC: llvm.mlir.constant(32 : index)
 
     // Check that the types are converted as expected.
-    // ALIGNED-ALLOC: llvm.call @aligned_alloc
+    // ALIGNED-ALLOC: llvm.call @_mlir_aligned_alloc
     // ALIGNED-ALLOC: llvm.bitcast %{{.*}} : !llvm.ptr<i8> to
     // ALIGNED-ALLOC-SAME: !llvm.
     // ALIGNED-ALLOC-SAME: [[INNER:ptr<struct<\(ptr<f32>, ptr<f32>, i32, array<1 x i32>, array<1 x i32>\)>>]]
     // ALIGNED-ALLOC: llvm.mlir.undef
     // ALIGNED-ALLOC-SAME: !llvm.struct<([[INNER]], [[INNER]], i32, array<1 x i32>, array<1 x i32>)>
     %0 = memref.alloc() : memref<1xmemref<1xf32>>
     return
   }
func.func @memref_of_memref_of_memref() {
   // ALIGNED-ALLOC-SAME:   )>
   // ALIGNED-ALLOC-SAME: >
   // ALIGNED-ALLOC: %[[PTR:.*]] = llvm.getelementptr
   // ALIGNED-ALLOC: %[[SIZEOF:.*]] = llvm.ptrtoint
 
   // Static alignment should be computed as ceilPowerOf2(2 * sizeof(pointer) +
   // (1 + 2 * rank) * sizeof(index) = ceilPowerOf2(2 * 8 + 3 * 8) = 64.
   // ALIGNED-ALLOC: llvm.mlir.constant(64 : index)
-  // ALIGNED-ALLOC: llvm.call @aligned_alloc
+  // ALIGNED-ALLOC: llvm.call @_mlir_aligned_alloc
   %0 = memref.alloc() : memref<1 x memref<2 x memref<3 x f32>>>
   return
 }
 
 // -----
 
 // ALIGNED-ALLOC-LABEL: @ranked_unranked
 func.func @ranked_unranked() {
   // ALIGNED-ALLOC: llvm.mlir.null
   // ALIGNED-ALLOC-SAME: !llvm.[[INNER:ptr<struct<\(i64, ptr<i8>\)>>]]
   // ALIGNED-ALLOC: llvm.getelementptr
   // ALIGNED-ALLOC: llvm.ptrtoint
 
   // Static alignment should be computed as ceilPowerOf2(sizeof(index) +
   // sizeof(pointer)) = 16.
   // ALIGNED-ALLOC: llvm.mlir.constant(16 : index)
-  // ALIGNED-ALLOC: llvm.call @aligned_alloc
+  // ALIGNED-ALLOC: llvm.call @_mlir_aligned_alloc
   // ALIGNED-ALLOC: llvm.bitcast
   // ALIGNED-ALLOC-SAME: !llvm.ptr<i8> to !llvm.[[INNER]]
   %0 = memref.alloc() : memref<1 x memref<* x f32>>
   memref.cast %0 : memref<1 x memref<* x f32>> to memref<* x memref<* x f32>>
   return
 }
 

mlir/test/Conversion/MemRefToLLVM/convert-static-memref-ops.mlir

 // RUN: mlir-opt -convert-memref-to-llvm -split-input-file %s | FileCheck %s
 
 // CHECK-LABEL: func @zero_d_alloc()
 func.func @zero_d_alloc() -> memref<f32> {
 // CHECK: %[[one:.*]] = llvm.mlir.constant(1 : index) : i64
 // CHECK: %[[null:.*]] = llvm.mlir.null : !llvm.ptr<f32>
 // CHECK: %[[gep:.*]] = llvm.getelementptr %[[null]][%[[one]]] : (!llvm.ptr<f32>, i64) -> !llvm.ptr<f32>
 // CHECK: %[[size_bytes:.*]] = llvm.ptrtoint %[[gep]] : !llvm.ptr<f32> to i64
-// CHECK: llvm.call @malloc(%[[size_bytes]]) : (i64) -> !llvm.ptr<i8>
+// CHECK: llvm.call @_mlir_alloc(%[[size_bytes]]) : (i64) -> !llvm.ptr<i8>
 // CHECK: %[[ptr:.*]] = llvm.bitcast %{{.*}} : !llvm.ptr<i8> to !llvm.ptr<f32>
 // CHECK: llvm.mlir.undef : !llvm.struct<(ptr<f32>, ptr<f32>, i64)>
 // CHECK: llvm.insertvalue %[[ptr]], %{{.*}}[0] : !llvm.struct<(ptr<f32>, ptr<f32>, i64)>
 // CHECK: llvm.insertvalue %[[ptr]], %{{.*}}[1] : !llvm.struct<(ptr<f32>, ptr<f32>, i64)>
 // CHECK: %[[c0:.*]] = llvm.mlir.constant(0 : index) : i64
 // CHECK: llvm.insertvalue %[[c0]], %{{.*}}[2] : !llvm.struct<(ptr<f32>, ptr<f32>, i64)>
 // CHECK: unrealized_conversion_cast %{{.*}}
 
   %0 = memref.alloc() : memref<f32>
   return %0 : memref<f32>
 }
 
 // -----
 
 // CHECK-LABEL: func @zero_d_dealloc
 func.func @zero_d_dealloc(%arg0: memref<f32>) {
 // CHECK: unrealized_conversion_cast
 // CHECK: %[[ptr:.*]] = llvm.extractvalue %{{.*}}[0] : !llvm.struct<(ptr<f32>, ptr<f32>, i64)>
 // CHECK: %[[bc:.*]] = llvm.bitcast %[[ptr]] : !llvm.ptr<f32> to !llvm.ptr<i8>
-// CHECK: llvm.call @free(%[[bc]]) : (!llvm.ptr<i8>) -> ()
+// CHECK: llvm.call @_mlir_free(%[[bc]]) : (!llvm.ptr<i8>) -> ()
 
   memref.dealloc %arg0 : memref<f32>
   return
 }
 
 // -----
 
 // CHECK-LABEL: func @aligned_1d_alloc(
 func.func @aligned_1d_alloc() -> memref<42xf32> {
 // CHECK: %[[sz1:.*]] = llvm.mlir.constant(42 : index) : i64
 // CHECK: %[[st1:.*]] = llvm.mlir.constant(1 : index) : i64
 // CHECK: %[[null:.*]] = llvm.mlir.null : !llvm.ptr<f32>
 // CHECK: %[[gep:.*]] = llvm.getelementptr %[[null]][%[[sz1]]] : (!llvm.ptr<f32>, i64) -> !llvm.ptr<f32>
 // CHECK: %[[size_bytes:.*]] = llvm.ptrtoint %[[gep]] : !llvm.ptr<f32> to i64
 // CHECK: %[[alignment:.*]] = llvm.mlir.constant(8 : index) : i64
 // CHECK: %[[allocsize:.*]] = llvm.add %[[size_bytes]], %[[alignment]] : i64
-// CHECK: %[[allocated:.*]] = llvm.call @malloc(%[[allocsize]]) : (i64) -> !llvm.ptr<i8>
+// CHECK: %[[allocated:.*]] = llvm.call @_mlir_alloc(%[[allocsize]]) : (i64) -> !llvm.ptr<i8>
 // CHECK: %[[ptr:.*]] = llvm.bitcast %{{.*}} : !llvm.ptr<i8> to !llvm.ptr<f32>
 // CHECK: %[[allocatedAsInt:.*]] = llvm.ptrtoint %[[ptr]] : !llvm.ptr<f32> to i64
 // CHECK: %[[one_1:.*]] = llvm.mlir.constant(1 : index) : i64
 // CHECK: %[[bump:.*]] = llvm.sub %[[alignment]], %[[one_1]] : i64
 // CHECK: %[[bumped:.*]] = llvm.add %[[allocatedAsInt]], %[[bump]] : i64
 // CHECK: %[[mod:.*]] = llvm.urem %[[bumped]], %[[alignment]] : i64
 // CHECK: %[[aligned:.*]] = llvm.sub %[[bumped]], %[[mod]] : i64
 // CHECK: %[[alignedBitCast:.*]] = llvm.inttoptr %[[aligned]] : i64 to !llvm.ptr<f32>

 // -----
 
 // CHECK-LABEL: func @static_alloc()
 func.func @static_alloc() -> memref<32x18xf32> {
 // CHECK: %[[num_elems:.*]] = llvm.mlir.constant(576 : index) : i64
 // CHECK: %[[null:.*]] = llvm.mlir.null : !llvm.ptr<f32>
 // CHECK: %[[gep:.*]] = llvm.getelementptr %[[null]][%[[num_elems]]] : (!llvm.ptr<f32>, i64) -> !llvm.ptr<f32>
 // CHECK: %[[size_bytes:.*]] = llvm.ptrtoint %[[gep]] : !llvm.ptr<f32> to i64
-// CHECK: %[[allocated:.*]] = llvm.call @malloc(%[[size_bytes]]) : (i64) -> !llvm.ptr<i8>
+// CHECK: %[[allocated:.*]] = llvm.call @_mlir_alloc(%[[size_bytes]]) : (i64) -> !llvm.ptr<i8>
 // CHECK: llvm.bitcast %[[allocated]] : !llvm.ptr<i8> to !llvm.ptr<f32>
  %0 = memref.alloc() : memref<32x18xf32>
  return %0 : memref<32x18xf32>
 }
 
 // -----
 
 // CHECK-LABEL: func @static_alloca()

 }
 
 // -----
 
 // CHECK-LABEL: func @static_dealloc
 func.func @static_dealloc(%static: memref<10x8xf32>) {
 // CHECK: %[[ptr:.*]] = llvm.extractvalue %{{.*}}[0] : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<2 x i64>, array<2 x i64>)>
 // CHECK: %[[bc:.*]] = llvm.bitcast %[[ptr]] : !llvm.ptr<f32> to !llvm.ptr<i8>
-// CHECK: llvm.call @free(%[[bc]]) : (!llvm.ptr<i8>) -> ()
+// CHECK: llvm.call @_mlir_free(%[[bc]]) : (!llvm.ptr<i8>) -> ()
   memref.dealloc %static : memref<10x8xf32>
   return
 }
 
 // -----
 
 // CHECK-LABEL: func @zero_d_load
 func.func @zero_d_load(%arg0: memref<f32>) -> f32 {
func.func @address() {
     %0 = memref.alloc(%c1) : memref<? x vector<2xf32>>
     // CHECK: %[[CST_S:.*]] = arith.constant 1 : index
     // CHECK: %[[CST:.*]] = builtin.unrealized_conversion_cast
     // CHECK: llvm.mlir.null
     // CHECK: llvm.getelementptr %{{.*}}[[CST]]
     // CHECK: llvm.ptrtoint %{{.*}} : !llvm.ptr<{{.*}}> to i32
     // CHECK: llvm.ptrtoint %{{.*}} : !llvm.ptr<{{.*}}> to i32
     // CHECK: llvm.add %{{.*}} : i32
-    // CHECK: llvm.call @malloc(%{{.*}}) : (i32) -> !llvm.ptr
+    // CHECK: llvm.call @_mlir_alloc(%{{.*}}) : (i32) -> !llvm.ptr
     // CHECK: llvm.ptrtoint %{{.*}} : !llvm.ptr<{{.*}}> to i32
     // CHECK: llvm.sub {{.*}} : i32
     // CHECK: llvm.add {{.*}} : i32
     // CHECK: llvm.urem {{.*}} : i32
     // CHECK: llvm.sub {{.*}} : i32
     // CHECK: llvm.inttoptr %{{.*}} : i32 to !llvm.ptr
     return
   }

mlir/test/Target/LLVMIR/llvmir.mlir

 // CHECK: @sectionvar = internal constant [10 x i8] c"teststring", section ".mysection"
 llvm.mlir.global internal constant @sectionvar("teststring")  {section = ".mysection"}: !llvm.array<10 x i8>
 
 //
 // Declarations of the allocation functions to be linked against. These are
 // inserted before other functions in the module.
 //
 
-// CHECK: declare ptr @malloc(i64)
-llvm.func @malloc(i64) -> !llvm.ptr<i8>
-// CHECK: declare void @free(ptr)
+// CHECK: declare ptr @_mlir_alloc(i64)
+llvm.func @_mlir_alloc(i64) -> !llvm.ptr<i8>
+// CHECK: declare void @_mlir_free(ptr)
 
 
 //
 // Basic functionality: function and block conversion, function calls,
 // phi nodes, scalar type conversion, arithmetic operations.
 //
 
 // CHECK-LABEL: define void @empty()

 }
 
 //
 // MemRef type conversion, allocation and communication with functions.
 //
 
 // CHECK-LABEL: define void @memref_alloc()
 llvm.func @memref_alloc() {
-// CHECK-NEXT: %{{[0-9]+}} = call ptr @malloc(i64 400)
+// CHECK-NEXT: %{{[0-9]+}} = call ptr @_mlir_alloc(i64 400)
 // CHECK-NEXT: %{{[0-9]+}} = insertvalue { ptr } undef, ptr %{{[0-9]+}}, 0
   %0 = llvm.mlir.constant(10 : index) : i64
   %1 = llvm.mlir.constant(10 : index) : i64
   %2 = llvm.mul %0, %1 : i64
   %3 = llvm.mlir.undef : !llvm.struct<(ptr<f32>)>
   %4 = llvm.mlir.constant(4 : index) : i64
   %5 = llvm.mul %2, %4 : i64
-  %6 = llvm.call @malloc(%5) : (i64) -> !llvm.ptr<i8>
+  %6 = llvm.call @_mlir_alloc(%5) : (i64) -> !llvm.ptr<i8>
   %7 = llvm.bitcast %6 : !llvm.ptr<i8> to !llvm.ptr<f32>
   %8 = llvm.insertvalue %7, %3[0] : !llvm.struct<(ptr<f32>)>
 // CHECK-NEXT: ret void
   llvm.return
 }
 
 // CHECK-LABEL: declare i64 @get_index()
 llvm.func @get_index() -> i64
 
 // CHECK-LABEL: define void @store_load_static()
 llvm.func @store_load_static() {
 ^bb0:
-// CHECK-NEXT: %{{[0-9]+}} = call ptr @malloc(i64 40)
+// CHECK-NEXT: %{{[0-9]+}} = call ptr @_mlir_alloc(i64 40)
 // CHECK-NEXT: %{{[0-9]+}} = insertvalue { ptr } undef, ptr %{{[0-9]+}}, 0
   %0 = llvm.mlir.constant(10 : index) : i64
   %1 = llvm.mlir.undef : !llvm.struct<(ptr<f32>)>
   %2 = llvm.mlir.constant(4 : index) : i64
   %3 = llvm.mul %0, %2 : i64
-  %4 = llvm.call @malloc(%3) : (i64) -> !llvm.ptr<i8>
+  %4 = llvm.call @_mlir_alloc(%3) : (i64) -> !llvm.ptr<i8>
   %5 = llvm.bitcast %4 : !llvm.ptr<i8> to !llvm.ptr<f32>
   %6 = llvm.insertvalue %5, %1[0] : !llvm.struct<(ptr<f32>)>
   %7 = llvm.mlir.constant(1.000000e+00 : f32) : f32
   llvm.br ^bb1
 ^bb1:   // pred: ^bb0
   %8 = llvm.mlir.constant(0 : index) : i64
   %9 = llvm.mlir.constant(10 : index) : i64
   llvm.br ^bb2(%8 : i64)

 ^bb8:   // pred: ^bb6
 // CHECK: ret void
   llvm.return
 }
 
 // CHECK-LABEL: define void @store_load_dynamic(i64 {{%.*}})
 llvm.func @store_load_dynamic(%arg0: i64) {
 // CHECK-NEXT: %{{[0-9]+}} = mul i64 %{{[0-9]+}}, 4
-// CHECK-NEXT: %{{[0-9]+}} = call ptr @malloc(i64 %{{[0-9]+}})
+// CHECK-NEXT: %{{[0-9]+}} = call ptr @_mlir_alloc(i64 %{{[0-9]+}})
 // CHECK-NEXT: %{{[0-9]+}} = insertvalue { ptr, i64 } undef, ptr %{{[0-9]+}}, 0
 // CHECK-NEXT: %{{[0-9]+}} = insertvalue { ptr, i64 } %{{[0-9]+}}, i64 %{{[0-9]+}}, 1
   %0 = llvm.mlir.undef : !llvm.struct<(ptr<f32>, i64)>
   %1 = llvm.mlir.constant(4 : index) : i64
   %2 = llvm.mul %arg0, %1 : i64
-  %3 = llvm.call @malloc(%2) : (i64) -> !llvm.ptr<i8>
+  %3 = llvm.call @_mlir_alloc(%2) : (i64) -> !llvm.ptr<i8>
   %4 = llvm.bitcast %3 : !llvm.ptr<i8> to !llvm.ptr<f32>
   %5 = llvm.insertvalue %4, %0[0] : !llvm.struct<(ptr<f32>, i64)>
   %6 = llvm.insertvalue %arg0, %5[1] : !llvm.struct<(ptr<f32>, i64)>
   %7 = llvm.mlir.constant(1.000000e+00 : f32) : f32
 // CHECK-NEXT: br label %{{[0-9]+}}
   llvm.br ^bb1
 ^bb1:   // pred: ^bb0
   %8 = llvm.mlir.constant(0 : index) : i64

 
 // CHECK-LABEL: define void @store_load_mixed(i64 {{%.*}})
 llvm.func @store_load_mixed(%arg0: i64) {
   %0 = llvm.mlir.constant(10 : index) : i64
 // CHECK-NEXT: %{{[0-9]+}} = mul i64 2, %{{[0-9]+}}
 // CHECK-NEXT: %{{[0-9]+}} = mul i64 %{{[0-9]+}}, 4
 // CHECK-NEXT: %{{[0-9]+}} = mul i64 %{{[0-9]+}}, 10
 // CHECK-NEXT: %{{[0-9]+}} = mul i64 %{{[0-9]+}}, 4
-// CHECK-NEXT: %{{[0-9]+}} = call ptr @malloc(i64 %{{[0-9]+}})
+// CHECK-NEXT: %{{[0-9]+}} = call ptr @_mlir_alloc(i64 %{{[0-9]+}})
 // CHECK-NEXT: %{{[0-9]+}} = insertvalue { ptr, i64, i64 } undef, ptr %{{[0-9]+}}, 0
 // CHECK-NEXT: %{{[0-9]+}} = insertvalue { ptr, i64, i64 } %{{[0-9]+}}, i64 %{{[0-9]+}}, 1
 // CHECK-NEXT: %{{[0-9]+}} = insertvalue { ptr, i64, i64 } %{{[0-9]+}}, i64 10, 2
   %1 = llvm.mlir.constant(2 : index) : i64
   %2 = llvm.mlir.constant(4 : index) : i64
   %3 = llvm.mul %1, %arg0 : i64
   %4 = llvm.mul %3, %2 : i64
   %5 = llvm.mul %4, %0 : i64
   %6 = llvm.mlir.undef : !llvm.struct<(ptr<f32>, i64, i64)>
   %7 = llvm.mlir.constant(4 : index) : i64
   %8 = llvm.mul %5, %7 : i64
-  %9 = llvm.call @malloc(%8) : (i64) -> !llvm.ptr<i8>
+  %9 = llvm.call @_mlir_alloc(%8) : (i64) -> !llvm.ptr<i8>
   %10 = llvm.bitcast %9 : !llvm.ptr<i8> to !llvm.ptr<f32>
   %11 = llvm.insertvalue %10, %6[0] : !llvm.struct<(ptr<f32>, i64, i64)>
   %12 = llvm.insertvalue %arg0, %11[1] : !llvm.struct<(ptr<f32>, i64, i64)>
   %13 = llvm.insertvalue %0, %12[2] : !llvm.struct<(ptr<f32>, i64, i64)>
 
 // CHECK-NEXT: %{{[0-9]+}} = call i64 @get_index()
 // CHECK-NEXT: %{{[0-9]+}} = call i64 @get_index()
   %14 = llvm.mlir.constant(1 : index) : i64
// CHECK-NEXT: store float 4.200000e+01, ptr %{{[0-9]+}}
   %10 = llvm.extractvalue %arg2[1] : !llvm.struct<(ptr<f32>, i64)>
   %11 = llvm.mul %0, %10 : i64
   %12 = llvm.add %11, %1 : i64
   %13 = llvm.extractvalue %arg2[0] : !llvm.struct<(ptr<f32>, i64)>
   %14 = llvm.getelementptr %13[%12] : (!llvm.ptr<f32>, i64) -> !llvm.ptr<f32>
   llvm.store %2, %14 : !llvm.ptr<f32>
 // CHECK-NEXT: %{{[0-9]+}} = mul i64 10, %{{[0-9]+}}
 // CHECK-NEXT: %{{[0-9]+}} = mul i64 %{{[0-9]+}}, 4
-// CHECK-NEXT: %{{[0-9]+}} = call ptr @malloc(i64 %{{[0-9]+}})
+// CHECK-NEXT: %{{[0-9]+}} = call ptr @_mlir_alloc(i64 %{{[0-9]+}})
 // CHECK-NEXT: %{{[0-9]+}} = insertvalue { ptr, i64 } undef, ptr %{{[0-9]+}}, 0
 // CHECK-NEXT: %{{[0-9]+}} = insertvalue { ptr, i64 } %{{[0-9]+}}, i64 %{{[0-9]+}}, 1
   %15 = llvm.mlir.constant(10 : index) : i64
   %16 = llvm.mul %15, %1 : i64
   %17 = llvm.mlir.undef : !llvm.struct<(ptr<f32>, i64)>
   %18 = llvm.mlir.constant(4 : index) : i64
   %19 = llvm.mul %16, %18 : i64
-  %20 = llvm.call @malloc(%19) : (i64) -> !llvm.ptr<i8>
+  %20 = llvm.call @_mlir_alloc(%19) : (i64) -> !llvm.ptr<i8>
   %21 = llvm.bitcast %20 : !llvm.ptr<i8> to !llvm.ptr<f32>
   %22 = llvm.insertvalue %21, %17[0] : !llvm.struct<(ptr<f32>, i64)>
   %23 = llvm.insertvalue %1, %22[1] : !llvm.struct<(ptr<f32>, i64)>
 // CHECK-NEXT: ret { ptr, i64 } %{{[0-9]+}}
   llvm.return %23 : !llvm.struct<(ptr<f32>, i64)>
 }
 
 

mlir/test/mlir-cpu-runner/bare-ptr-call-conv.mlir

-// RUN: mlir-opt %s -pass-pipeline="func.func(convert-scf-to-cf,convert-arith-to-llvm),convert-memref-to-llvm,convert-func-to-llvm{use-bare-ptr-memref-call-conv=1}" -reconcile-unrealized-casts | mlir-cpu-runner -shared-libs=%linalg_test_lib_dir/libmlir_c_runner_utils%shlibext -entry-point-result=void | FileCheck %s
+// RUN: mlir-opt %s -pass-pipeline="func.func(convert-scf-to-cf,convert-arith-to-llvm),convert-memref-to-llvm,convert-func-to-llvm{use-bare-ptr-memref-call-conv=1}" -reconcile-unrealized-casts \
+// RUN: | mlir-cpu-runner -shared-libs=%mlir_runner_utils_dir/libmlir_runner_utils%shlibext,%linalg_test_lib_dir/libmlir_c_runner_utils%shlibext -entry-point-result=void \
+// RUN: | FileCheck %s
 
 // Verify bare pointer memref calling convention. `simple_add1_add2_test`
 // gets two 2xf32 memrefs, adds 1.0f to the first one and 2.0f to the second
 // one. 'main' calls 'simple_add1_add2_test' with {1, 1} and {2, 2} so {2, 2}
 // and {4, 4} are the expected outputs.
 
 func.func @simple_add1_add2_test(%arg0: memref<2xf32>, %arg1: memref<2xf32>) {
   %c2 = arith.constant 2 : index
scf.for %arg2 = %c0 to %c2 step %c1 {
     %3 = arith.addf %1, %cst_0 : f32
     memref.store %3, %arg1[%arg2] : memref<2xf32>
     // CHECK-NEXT: 4, 4
   }
   return
 }
 
 // External declarations.
-llvm.func @malloc(i64) -> !llvm.ptr<i8>
-llvm.func @free(!llvm.ptr<i8>)
+llvm.func @_mlir_alloc(i64) -> !llvm.ptr<i8>
+llvm.func @_mlir_free(!llvm.ptr<i8>)
 func.func private @printF32(%arg0: f32)
 func.func private @printComma()
 func.func private @printNewline()
 
 func.func @main()
 {
   %c2 = arith.constant 2 : index
   %c0 = arith.constant 0 : index

mlir/test/mlir-cpu-runner/sgemm-naive-codegen.mlir

-// RUN: mlir-opt -pass-pipeline="func.func(convert-linalg-to-loops,lower-affine,convert-scf-to-cf,convert-arith-to-llvm),convert-vector-to-llvm,convert-memref-to-llvm,convert-func-to-llvm,reconcile-unrealized-casts" %s | mlir-cpu-runner -O3 -e main -entry-point-result=void -shared-libs=%mlir_runner_utils_dir/libmlir_c_runner_utils%shlibext | FileCheck %s
+// RUN: mlir-opt -pass-pipeline="func.func(convert-linalg-to-loops,lower-affine,convert-scf-to-cf,convert-arith-to-llvm),convert-vector-to-llvm,convert-memref-to-llvm,convert-func-to-llvm,reconcile-unrealized-casts" %s \
+// RUN: | mlir-cpu-runner -O3 -e main -entry-point-result=void -shared-libs=%mlir_runner_utils_dir/libmlir_runner_utils%shlibext,%mlir_runner_utils_dir/libmlir_c_runner_utils%shlibext \
+// RUN: | FileCheck %s
 
 func.func @main() {
   %A = memref.alloc() : memref<16x16xf32>
   %B = memref.alloc() : memref<16x16xf32>
   %C = memref.alloc() : memref<16x16xf32>
 
   %cf1 = arith.constant 1.00000e+00 : f32
 

mlir/test/mlir-cpu-runner/simple.mlir

-// RUN: mlir-cpu-runner %s | FileCheck %s
-// RUN: mlir-cpu-runner %s -e foo | FileCheck -check-prefix=NOMAIN %s
-// RUN: mlir-cpu-runner %s --entry-point-result=i32 -e int32_main | FileCheck -check-prefix=INT32MAIN %s
-// RUN: mlir-cpu-runner %s --entry-point-result=i64 -e int64_main | FileCheck -check-prefix=INT64MAIN %s
-// RUN: mlir-cpu-runner %s -O3 | FileCheck %s
+// RUN: mlir-cpu-runner %s \
+// RUN: -shared-libs=%mlir_runner_utils_dir/libmlir_runner_utils%shlibext,%mlir_runner_utils_dir/libmlir_c_runner_utils%shlibext \
+// RUN: | FileCheck %s
+
+// RUN: mlir-cpu-runner %s -e foo \
+// RUN: -shared-libs=%mlir_runner_utils_dir/libmlir_runner_utils%shlibext,%mlir_runner_utils_dir/libmlir_c_runner_utils%shlibext \
+// RUN: | FileCheck -check-prefix=NOMAIN %s
+
+// RUN: mlir-cpu-runner %s --entry-point-result=i32 -e int32_main \
+// RUN: -shared-libs=%mlir_runner_utils_dir/libmlir_runner_utils%shlibext,%mlir_runner_utils_dir/libmlir_c_runner_utils%shlibext \
+// RUN: | FileCheck -check-prefix=INT32MAIN %s
+
+// RUN: mlir-cpu-runner %s --entry-point-result=i64 -e int64_main \
+// RUN: -shared-libs=%mlir_runner_utils_dir/libmlir_runner_utils%shlibext,%mlir_runner_utils_dir/libmlir_c_runner_utils%shlibext \
+// RUN: | FileCheck -check-prefix=INT64MAIN %s
+
+// RUN: mlir-cpu-runner %s -O3 \
+// RUN: -shared-libs=%mlir_runner_utils_dir/libmlir_runner_utils%shlibext,%mlir_runner_utils_dir/libmlir_c_runner_utils%shlibext \
+// RUN: | FileCheck %s
 
 // RUN: cp %s %t
-// RUN: mlir-cpu-runner %t -dump-object-file | FileCheck %t
+// RUN: mlir-cpu-runner %t -dump-object-file -shared-libs=%mlir_runner_utils_dir/libmlir_runner_utils%shlibext,%mlir_runner_utils_dir/libmlir_c_runner_utils%shlibext | FileCheck %t
 // RUN: ls %t.o
 // RUN: rm %t.o
 
-// RUN: mlir-cpu-runner %s -dump-object-file -object-filename=%T/test.o | FileCheck %s
+// RUN: mlir-cpu-runner %s -dump-object-file -object-filename=%T/test.o -shared-libs=%mlir_runner_utils_dir/libmlir_runner_utils%shlibext,%mlir_runner_utils_dir/libmlir_c_runner_utils%shlibext | FileCheck %s
 // RUN: ls %T/test.o
 // RUN: rm %T/test.o
 
 // Declarations of C library functions.
 llvm.func @fabsf(f32) -> f32
-llvm.func @malloc(i64) -> !llvm.ptr<i8>
-llvm.func @free(!llvm.ptr<i8>)
+llvm.func @_mlir_alloc(i64) -> !llvm.ptr<i8>
+llvm.func @_mlir_free(!llvm.ptr<i8>)
 
 // Check that a simple function with a nested call works.
 llvm.func @main() -> f32 {
   %0 = llvm.mlir.constant(-4.200000e+02 : f32) : f32
   %1 = llvm.call @fabsf(%0) : (f32) -> f32
   llvm.return %1 : f32
 }
 // CHECK: 4.200000e+02
 
-// Helper typed functions wrapping calls to "malloc" and "free".
+// Helper typed functions wrapping calls to "_mlir_alloc" and "_mlir_free".
 llvm.func @allocation() -> !llvm.ptr<f32> {
   %0 = llvm.mlir.constant(4 : index) : i64
-  %1 = llvm.call @malloc(%0) : (i64) -> !llvm.ptr<i8>
+  %1 = llvm.call @_mlir_alloc(%0) : (i64) -> !llvm.ptr<i8>
   %2 = llvm.bitcast %1 : !llvm.ptr<i8> to !llvm.ptr<f32>
   llvm.return %2 : !llvm.ptr<f32>
 }
 llvm.func @deallocation(%arg0: !llvm.ptr<f32>) {
   %0 = llvm.bitcast %arg0 : !llvm.ptr<f32> to !llvm.ptr<i8>
-  llvm.call @free(%0) : (!llvm.ptr<i8>) -> ()
+  llvm.call @_mlir_free(%0) : (!llvm.ptr<i8>) -> ()
   llvm.return
 }
 
 // Check that allocation and deallocation works, and that a custom entry point
 // works.
 llvm.func @foo() -> f32 {
   %0 = llvm.call @allocation() : () -> !llvm.ptr<f32>
   %1 = llvm.mlir.constant(0 : index) : i64