diff --git a/CMakeLists.txt b/CMakeLists.txt
index 7684247..46c99c9 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -92,7 +92,7 @@ target_include_directories(MPIToLLVMConversion
# Add executable and link it with the parser library
-add_llvm_executable(dhir-opt main.cc libs/avialDialect.cc libs/avialOps.cc libs/utils.cc DEPENDS MLIRAvialDialectIncGen)
+add_llvm_executable(dhir-opt main.cc libs/dhirDialect.cc libs/dhirOps.cc libs/utils.cc DEPENDS MLIRDhirDialectIncGen)
target_link_libraries(dhir-opt
PRIVATE
diff --git a/README.md b/README.md
index 144dcd9..83904fa 100644
--- a/README.md
+++ b/README.md
@@ -1,5 +1,5 @@
-# 🥗 Avial : An MLIR Dialect for Distributed Heterogeneous Computing
-Avial is a compiler infrastructure built using MLIR that enables efficient execution of programs across distributed and heterogeneous computing systems (CPU, GPU, cluster). Avial introduces a novel task-centric intermediate representation (IR) where tasks are first-class citizens, capturing their parallelism, device targets, and interdependencies.
+# 🥗 DHIR : An MLIR Dialect for Distributed Heterogeneous Computing
+DHIR is a compiler infrastructure built using MLIR that enables efficient execution of programs across distributed and heterogeneous computing systems (CPU, GPU, cluster). DHIR introduces a novel task-centric intermediate representation (IR) where tasks are first-class citizens, capturing their parallelism, device targets, and interdependencies.
## 🚧 Project Status


@@ -15,7 +15,7 @@ Parallel programming is notoriously difficult. Developers must reason about conc
Unifying these paradigms into a single coherent programming or compilation model is non-trivial due to fundamental differences in their memory models, synchronization semantics, and communication mechanisms. While there have been commendable efforts at unifying heterogeneous computing within a node. Such as OpenCL, OpenACC, and more recently Mojo. There is a noticeable gap when it comes to extending these unifications across distributed environments. The gap remains largely due to the complexity of distributed computing: issues such as explicit data movement between the nodes and network topology cannot be abstracted away as easily.
-## Why Avial Is Unique?
+## Why DHIR Is Unique?
While MLIR includes dialects like omp for shared-memory parallelism and gpu for targeting accelerators such as CUDA or ROCm, there is currently no dialect that provides a unified abstraction for distributed heterogeneous computing, that is, for clusters of nodes with diverse compute units like CPUs and GPUs.
@@ -38,6 +38,6 @@ Here's how it works in practice:
- Lowers the task to the different backend (e.g., LLVM, CUDA, ROCm)
- Handles device setup and data movement
-Thanks to the `CodeDrop` approach, integrating the Avial dialect into existing compiler pipelines is both trivial and non-intrusive. The process begins by identifying performance-critical regions such as loops, compute kernels, or math-heavy operations regardless of which dialect they're written in. These regions are then wrapped in a TaskOp. That’s it. From there, Avial takes full control, automatically lowering tasks to the appropriate execution backends including MPI for distributed execution and ultimately to LLVM IR.
+Thanks to the `CodeDrop` approach, integrating the DHIR dialect into existing compiler pipelines is both trivial and non-intrusive. The process begins by identifying performance-critical regions such as loops, compute kernels, or math-heavy operations regardless of which dialect they're written in. These regions are then wrapped in a TaskOp. That’s it. From there, DHIR takes full control, automatically lowering tasks to the appropriate execution backends including MPI for distributed execution and ultimately to LLVM IR.
-This approach not only simplifies integration but also scales easily across heterogeneous and distributed environments. Whether running on a single multicore CPU or across a CPU-GPU cluster with MPI, Avial ensures consistent handling of task distribution and coordination.
+This approach not only simplifies integration but also scales easily across heterogeneous and distributed environments. Whether running on a single multicore CPU or across a CPU-GPU cluster with MPI, DHIR ensures consistent handling of task distribution and coordination.
diff --git a/analysis/arrayPartitionAnalysis.h b/analysis/arrayPartitionAnalysis.h
index f797b89..2a4a42c 100644
--- a/analysis/arrayPartitionAnalysis.h
+++ b/analysis/arrayPartitionAnalysis.h
@@ -11,7 +11,7 @@
namespace mlir
{
- namespace avial
+ namespace dhir
{
struct ArrayPartitioningInfo
{
@@ -752,7 +752,7 @@ namespace mlir
return analysis.analyzeArray(memref);
}
- } // namespace avial
+ } // namespace dhir
} // namespace mlir
#endif
\ No newline at end of file
diff --git a/analysis/broadcastAnalysis.h b/analysis/broadcastAnalysis.h
index efc0a32..a185bd3 100644
--- a/analysis/broadcastAnalysis.h
+++ b/analysis/broadcastAnalysis.h
@@ -12,13 +12,13 @@
#include
#include "arrayPartitionAnalysis.h"
-#include "includes/avialOps.h"
-#include "includes/avialDialect.h"
+#include "includes/dhirOps.h"
+#include "includes/dhirDialect.h"
namespace mlir
{
- namespace avial
+ namespace dhir
{
// ========================================================================
@@ -48,7 +48,7 @@ namespace mlir
// Get all write arguments from this replicate operation
- llvm::SmallVector writeArgs = mlir::dyn_cast(replicateOp).getWrites();
+ llvm::SmallVector writeArgs = mlir::dyn_cast(replicateOp).getWrites();
if (writeArgs.empty()) {
llvm::errs() << "No write arguments found in replicate operation\n";
@@ -142,7 +142,7 @@ namespace mlir
// Walk through all operations in the parent
- parentOp->walk([&](mlir::avial::ReplicateOp op) {
+ parentOp->walk([&](mlir::dhir::ReplicateOp op) {
// Skip until we find the current replicate operation
if (op == replicateOp) {
foundCurrentReplicate = true;
@@ -165,7 +165,7 @@ namespace mlir
// Check if a memref is read by a replicate operation
bool isReadByReplicate(mlir::Operation *replicate, Value memref)
{
- llvm::SmallVector readArgs = mlir::dyn_cast(replicate).getReads();
+ llvm::SmallVector readArgs = mlir::dyn_cast(replicate).getReads();
llvm::errs() << "Memref: ";
memref.dump();
for (Value readArg : readArgs) {
@@ -222,7 +222,7 @@ namespace mlir
return false; // Not found, default to no broadcast
}
- } // namespace avial
+ } // namespace dhir
} // namespace mlir
/*
@@ -233,10 +233,10 @@ namespace mlir
* #include "BroadcastAnalysis.h"
*
* void processReplicateOp(mlir::Operation *replicateOp) {
- * std::vector broadcastDecisions;
+ * std::vector broadcastDecisions;
*
* // Analyze the replicate operation
- * if (!mlir::avial::analyzeBroadcastRequirements(replicateOp, broadcastDecisions)) {
+ * if (!mlir::dhir::analyzeBroadcastRequirements(replicateOp, broadcastDecisions)) {
* llvm::errs() << "Broadcast analysis failed!\n";
* return;
* }
diff --git a/analysis/depGraph.h b/analysis/depGraph.h
index 022e99a..55381c4 100644
--- a/analysis/depGraph.h
+++ b/analysis/depGraph.h
@@ -1,9 +1,9 @@
#include "mlir/Conversion/Passes.h"
#include "mlir/Pass/PassManager.h"
-#include "includes/avialDialect.h"
+#include "includes/dhirDialect.h"
#include "mlir/Dialect/MemRef/IR/MemRef.h"
-#include "includes/avialOps.h"
+#include "includes/dhirOps.h"
#include "mlir/Dialect/SCF/IR/SCF.h"
enum class TargetType
@@ -146,7 +146,7 @@ bool memoryAccessesConflict(mlir::Value val1, mlir::Value val2)
namespace mlir
{
- namespace avial
+ namespace dhir
{
struct DependencyGraph
@@ -158,7 +158,7 @@ namespace mlir
bool hasLoop; // Whether tasks are inside a loop
mlir::scf::ForOp forLoop; // The loop containing tasks (if any)
- void build(avial::ScheduleOp schedule)
+ void build(dhir::ScheduleOp schedule)
{
llvm::errs() << "-- Building task dependency graph\n";
diff --git a/analysis/insoutAnalysis.h b/analysis/insoutAnalysis.h
index 1f55d4d..942ffdc 100644
--- a/analysis/insoutAnalysis.h
+++ b/analysis/insoutAnalysis.h
@@ -9,8 +9,8 @@
#include "mlir/IR/MLIRContext.h"
#include "mlir/IR/BuiltinOps.h"
-#include "includes/avialOps.h"
-#include "includes/avialDialect.h"
+#include "includes/dhirOps.h"
+#include "includes/dhirDialect.h"
struct InsOutsAnalysis
{
@@ -19,7 +19,7 @@ struct InsOutsAnalysis
InsOutsAnalysis(mlir::Operation *op)
{
- if (auto schOp = mlir::dyn_cast(op))
+ if (auto schOp = mlir::dyn_cast(op))
{
if (mlir::Block *block = &schOp.getRegion().front())
{
diff --git a/analysis/polyhedralAnalysis.h b/analysis/polyhedralAnalysis.h
index 8fee26f..c64d968 100644
--- a/analysis/polyhedralAnalysis.h
+++ b/analysis/polyhedralAnalysis.h
@@ -13,7 +13,7 @@
namespace mlir
{
- namespace avial
+ namespace dhir
{
int checkLoopDependence(mlir::affine::AffineForOp op, int depth)
{
diff --git a/conversions/affinetoavial.h b/conversions/affinetodhir.h
similarity index 92%
rename from conversions/affinetoavial.h
rename to conversions/affinetodhir.h
index 4b4ed8e..803ff96 100644
--- a/conversions/affinetoavial.h
+++ b/conversions/affinetodhir.h
@@ -1,8 +1,8 @@
#include "mlir/Pass/PassManager.h"
#include "mlir/IR/PatternMatch.h"
-#include "includes/avialDialect.h"
-#include "includes/avialTypes.h"
+#include "includes/dhirDialect.h"
+#include "includes/dhirTypes.h"
#include "mlir/Transforms/DialectConversion.h"
@@ -14,9 +14,9 @@
#include "mlir/Dialect/Func/IR/FuncOps.h"
#include "mlir/Dialect/SCF/IR/SCF.h"
-#include "includes/avialDialect.h"
-#include "includes/avialOps.h"
-#include "includes/avialTypes.h"
+#include "includes/dhirDialect.h"
+#include "includes/dhirOps.h"
+#include "includes/dhirTypes.h"
#include "includes/utils.h"
#include "mlir/Dialect/DLTI/DLTI.h"
@@ -29,20 +29,20 @@
#include
using namespace mlir;
-using namespace avial;
+using namespace dhir;
namespace mlir
{
- namespace avial
+ namespace dhir
{
-#define GEN_PASS_DEF_CONVERTAFFINETOAVIALPASS
+#define GEN_PASS_DEF_CONVERTAFFINETODHIRPASS
#include "dialect/Passes.h.inc"
- struct ConvertAffineToAvialPass : public mlir::avial::impl::ConvertAffineToAvialPassBase
+ struct ConvertAffineToDhirPass : public mlir::dhir::impl::ConvertAffineToDhirPassBase
{
- using ConvertAffineToAvialPassBase::ConvertAffineToAvialPassBase;
+ using ConvertAffineToDhirPassBase::ConvertAffineToDhirPassBase;
// Helper function to check if a loop is independent (considering only its own iterations)
// This checks the loop in isolation, not in the context of parent loops
@@ -146,7 +146,7 @@ namespace mlir
bool isStencil = false;
- mlir::avial::ArrayPartitioningAnalysis analysis(forOp);
+ mlir::dhir::ArrayPartitioningAnalysis analysis(forOp);
for (Value in : insouts[0])
{
auto info = analysis.analyzeArray(in);
@@ -162,7 +162,7 @@ namespace mlir
}
builder.setInsertionPoint(forOp);
- auto replicateOp = builder.create(forOp.getLoc(), insouts[0], insouts[1]);
+ auto replicateOp = builder.create(forOp.getLoc(), insouts[0], insouts[1]);
replicateOp->setAttr("replicateID", builder.getI64IntegerAttr(repId));
if (isStencil)
@@ -175,7 +175,7 @@ namespace mlir
forOp->moveBefore(newBlock, newBlock->end());
builder.setInsertionPointToEnd(newBlock);
- builder.create(builder.getUnknownLoc());
+ builder.create(builder.getUnknownLoc());
llvm::errs() << "Wrapped loop with ReplicateOp (replicateID=" << repId << ")\n";
++repId;
@@ -275,7 +275,7 @@ namespace mlir
auto insouts = InsOutsAnalysis::getInsandOut(forOp);
builder.setInsertionPoint(forOp);
- auto replicateOp = builder.create(forOp.getLoc(), insouts[0], insouts[1]);
+ auto replicateOp = builder.create(forOp.getLoc(), insouts[0], insouts[1]);
replicateOp->setAttr("replicateID", builder.getI64IntegerAttr(repId));
mlir::Region &replicateRegion = replicateOp.getBodyRegion();
@@ -283,7 +283,7 @@ namespace mlir
forOp->moveBefore(newBlock, newBlock->end());
builder.setInsertionPointToEnd(newBlock);
- builder.create(builder.getUnknownLoc());
+ builder.create(builder.getUnknownLoc());
++repId;
}
@@ -301,7 +301,7 @@ namespace mlir
auto insouts = InsOutsAnalysis::getInsandOut(forOp);
builder.setInsertionPoint(forOp);
- auto convergeOp = builder.create(forOp.getLoc(), insouts[0], insouts[1]);
+ auto convergeOp = builder.create(forOp.getLoc(), insouts[0], insouts[1]);
convergeOp->setAttr("ConvergeID", builder.getI64IntegerAttr(taskId));
mlir::Region &ConvergeRegion = convergeOp.getBodyRegion();
@@ -309,7 +309,7 @@ namespace mlir
forOp->moveBefore(newBlock, newBlock->end());
builder.setInsertionPointToEnd(newBlock);
- builder.create(builder.getUnknownLoc());
+ builder.create(builder.getUnknownLoc());
++taskId;
}
diff --git a/conversions/avialirtompi.h b/conversions/dhirtompi.h
similarity index 96%
rename from conversions/avialirtompi.h
rename to conversions/dhirtompi.h
index 8852d72..89a8082 100644
--- a/conversions/avialirtompi.h
+++ b/conversions/dhirtompi.h
@@ -3,8 +3,8 @@
#include "mlir/IR/PatternMatch.h"
#include "mlir/IR/Verifier.h"
-#include "includes/avialDialect.h"
-#include "includes/avialTypes.h"
+#include "includes/dhirDialect.h"
+#include "includes/dhirTypes.h"
#include "includes/utils.h"
#include "mlir/Dialect/MemRef/IR/MemRef.h"
@@ -45,7 +45,7 @@ mlir::Value materializeOpFoldResult(mlir::OpFoldResult ofr, mlir::ConversionPatt
static mlir::SmallVector materializeOpFoldResults(mlir::ConversionPatternRewriter &rewriter, mlir::ArrayRef ofrs);
using namespace mlir;
-using namespace avial;
+using namespace dhir;
#include "mlir/Dialect/GPU/Transforms/ParallelLoopMapper.h"
#include "mlir/Dialect/GPU/IR/GPUDialect.h"
@@ -271,8 +271,8 @@ static SmallVector materializeOpFoldResults(ConversionPatternRewriter &re
static Value createRuntimeTopology(ModuleOp module, ConversionPatternRewriter &rewriter, Location loc)
{
- auto devicesAttr = module->getAttrOfType("avial.target_devices");
- assert(devicesAttr && "No avial.target_devices attribute found");
+ auto devicesAttr = module->getAttrOfType("dhir.target_devices");
+ assert(devicesAttr && "No dhir.target_devices attribute found");
struct NodeInfo
{
@@ -388,12 +388,12 @@ static Value createRuntimeTopology(ModuleOp module, ConversionPatternRewriter &r
return topology;
}
-struct ConvertScheduleOp : public OpConversionPattern
+struct ConvertScheduleOp : public OpConversionPattern
{
using OpConversionPattern::OpConversionPattern;
LogicalResult matchAndRewrite(
- mlir::avial::ScheduleOp op, OpAdaptor adaptor,
+ mlir::dhir::ScheduleOp op, OpAdaptor adaptor,
ConversionPatternRewriter &rewriter) const override
{
@@ -452,7 +452,7 @@ struct ConvertScheduleOp : public OpConversionPattern
Value topology = createRuntimeTopology(module, rewriter, loc);
- auto devicesAttr = module->getAttrOfType("avial.target_devices");
+ auto devicesAttr = module->getAttrOfType("dhir.target_devices");
int numNodes = devicesAttr.size();
auto mapType = MemRefType::get({numNodes}, rewriter.getI32Type());
@@ -513,8 +513,8 @@ struct ConvertScheduleOp : public OpConversionPattern
// Clone constants and non-task, non-loop operations
for (auto &innerOp : op.getBodyRegion().front().getOperations())
{
- if (mlir::isa(innerOp) ||
- mlir::isa(innerOp) ||
+ if (mlir::isa(innerOp) ||
+ mlir::isa(innerOp) ||
mlir::isa(innerOp))
continue;
@@ -544,7 +544,7 @@ struct ConvertScheduleOp : public OpConversionPattern
for (auto &loopOp : outerLoop.getBody()->getOperations())
{
- if (mlir::isa(loopOp) || mlir::isa(loopOp))
+ if (mlir::isa(loopOp) || mlir::isa(loopOp))
continue;
Operation *clonedOp = rewriter.clone(loopOp, mapping);
@@ -567,7 +567,7 @@ struct ConvertScheduleOp : public OpConversionPattern
for (auto task : level)
{
- auto taskOp = dyn_cast(task->op);
+ auto taskOp = dyn_cast(task->op);
Attribute targetDevice = taskOp.getTarget();
// if task target device has no matches in the deviceToIndex map, something is broken on our end.
@@ -662,7 +662,7 @@ struct ConvertScheduleOp : public OpConversionPattern
}
for (auto &op : taskBlock) {
- if (mlir::isa(op))
+ if (mlir::isa(op))
continue;
Operation *clonedOp = ifbuilder.clone(op, rankMapping);
@@ -695,7 +695,7 @@ struct ConvertScheduleOp : public OpConversionPattern
for (auto task : level)
{
- auto taskOp = dyn_cast(task->op);
+ auto taskOp = dyn_cast(task->op);
Attribute targetDevice = taskOp.getTarget();
assert(deviceToIndex.count(targetDevice) && "Task target device not found in deviceToIndex map");
@@ -848,14 +848,14 @@ struct ConvertScheduleOp : public OpConversionPattern
namespace mlir
{
- namespace avial
+ namespace dhir
{
-#define GEN_PASS_DEF_CONVERTAVIALIRTOMPIPASS
+#define GEN_PASS_DEF_CONVERTDHIRTOMPIPASS
#include "dialect/Passes.h.inc"
- struct ConvertAvialIRToMPIPass : public mlir::avial::impl::ConvertAvialIRToMPIPassBase
+ struct ConvertDhirToMPIPass : public mlir::dhir::impl::ConvertDhirToMPIPassBase
{
- using ConvertAvialIRToMPIPassBase::ConvertAvialIRToMPIPassBase;
+ using ConvertDhirToMPIPassBase::ConvertDhirToMPIPassBase;
void getDependentDialects(DialectRegistry ®istry) const override
{
@@ -888,14 +888,14 @@ namespace mlir
target.addLegalDialect();
target.addLegalDialect();
- target.addIllegalOp();
+ target.addIllegalOp();
targetReplicateOp.addLegalDialect();
targetReplicateOp.addLegalDialect();
- targetReplicateOp.addLegalOp();
- targetReplicateOp.addIllegalOp();
- targetReplicateOp.addLegalOp();
+ targetReplicateOp.addLegalOp();
+ targetReplicateOp.addIllegalOp();
+ targetReplicateOp.addLegalOp();
targetReplicateOp.addLegalDialect();
targetTaskOp.addLegalDialect();
@@ -903,13 +903,13 @@ namespace mlir
// targetTaskOp.addIllegalOp();
targetTaskOp.addLegalOp();
targetTaskOp.markOpRecursivelyLegal();
- targetTaskOp.addLegalDialect();
+ targetTaskOp.addLegalDialect();
targetTaskOp.addLegalDialect();
- // RewritePatternSet avialpatterns(context);
- // avialpatterns.add(context);
+ // RewritePatternSet dhirpatterns(context);
+ // dhirpatterns.add(context);
- // if (failed(applyPartialConversion(module, targetReplicateOp, std::move(avialpatterns))))
+ // if (failed(applyPartialConversion(module, targetReplicateOp, std::move(dhirpatterns))))
// {
// signalPassFailure();
// }
diff --git a/conversions/lowerConvergeOp.h b/conversions/lowerConvergeOp.h
index fe432f4..322ffa8 100644
--- a/conversions/lowerConvergeOp.h
+++ b/conversions/lowerConvergeOp.h
@@ -1,8 +1,8 @@
#include "mlir/Transforms/DialectConversion.h"
#include "mlir/Transforms/GreedyPatternRewriteDriver.h"
#include "mlir/Conversion/Passes.h"
-#include "includes/avialDialect.h"
-#include "includes/avialTypes.h"
+#include "includes/dhirDialect.h"
+#include "includes/dhirTypes.h"
#include "includes/utils.h"
#include "analysis/arrayPartitionAnalysis.h"
#include "mlir/Dialect/Func/IR/FuncOps.h"
@@ -13,20 +13,20 @@
using namespace mlir;
-struct ConvertConvergeOp : public OpConversionPattern
+struct ConvertConvergeOp : public OpConversionPattern
{
using OpConversionPattern::OpConversionPattern;
LogicalResult matchAndRewrite(
- mlir::avial::ConvergeOp op, OpAdaptor adaptor,
+ mlir::dhir::ConvergeOp op, OpAdaptor adaptor,
ConversionPatternRewriter &rewriter) const override
{
llvm::errs() << "---- Processing ConvergeOp ----\n";
// Collect all TaskOps in the ConvergeOp's body
- llvm::SmallVector allTasks;
+ llvm::SmallVector allTasks;
- op.getBodyRegion().walk([&](mlir::avial::TaskOp taskOp) {
+ op.getBodyRegion().walk([&](mlir::dhir::TaskOp taskOp) {
allTasks.push_back(taskOp);
});
@@ -110,13 +110,13 @@ struct ConvertConvergeOp : public OpConversionPattern
namespace mlir
{
- namespace avial
+ namespace dhir
{
#define GEN_PASS_DEF_LOWERCONVERGEOPPASS
#include "dialect/Passes.h.inc"
struct LowerConvergeOpPass
- : public mlir::avial::impl::LowerConvergeOpPassBase
+ : public mlir::dhir::impl::LowerConvergeOpPassBase
{
using LowerConvergeOpPassBase::LowerConvergeOpPassBase;
@@ -129,18 +129,18 @@ namespace mlir
targetReplicateOp.addLegalDialect();
targetReplicateOp.addLegalDialect();
targetReplicateOp.addLegalDialect();
- targetReplicateOp.addLegalOp();
- targetReplicateOp.addLegalOp();
- targetReplicateOp.addLegalOp();
+ targetReplicateOp.addLegalOp();
+ targetReplicateOp.addLegalOp();
+ targetReplicateOp.addLegalOp();
targetReplicateOp.addLegalDialect();
// Mark ConvergeOp as illegal - it should be removed
- targetReplicateOp.addIllegalOp();
+ targetReplicateOp.addIllegalOp();
- RewritePatternSet avialpatterns(context);
- avialpatterns.add(context);
+ RewritePatternSet dhirpatterns(context);
+ dhirpatterns.add(context);
- if (failed(applyPartialConversion(module, targetReplicateOp, std::move(avialpatterns))))
+ if (failed(applyPartialConversion(module, targetReplicateOp, std::move(dhirpatterns))))
{
signalPassFailure();
}
diff --git a/conversions/lowerReplicateOp.h b/conversions/lowerReplicateOp.h
index 121774c..006f113 100644
--- a/conversions/lowerReplicateOp.h
+++ b/conversions/lowerReplicateOp.h
@@ -2,8 +2,8 @@
#include "mlir/Transforms/GreedyPatternRewriteDriver.h"
#include "mlir/Conversion/Passes.h"
-#include "includes/avialDialect.h"
-#include "includes/avialTypes.h"
+#include "includes/dhirDialect.h"
+#include "includes/dhirTypes.h"
#include "includes/utils.h"
#include "analysis/arrayPartitionAnalysis.h"
@@ -18,12 +18,12 @@
using namespace mlir;
-struct ConvertReplicateOp : public OpConversionPattern
+struct ConvertReplicateOp : public OpConversionPattern
{
using OpConversionPattern::OpConversionPattern;
LogicalResult matchAndRewrite(
- mlir::avial::ReplicateOp op, OpAdaptor adaptor,
+ mlir::dhir::ReplicateOp op, OpAdaptor adaptor,
ConversionPatternRewriter &rewriter) const override
{
@@ -32,7 +32,7 @@ struct ConvertReplicateOp : public OpConversionPattern
module = module->getParentOp();
mlir::Operation *schOp = op;
- while (schOp && !mlir::isa(schOp))
+ while (schOp && !mlir::isa(schOp))
{
if (mlir::isa(schOp))
{
@@ -121,8 +121,8 @@ struct ConvertReplicateOp : public OpConversionPattern
int64_t ub = constupperBound;
int64_t lb = constlowerBound;
int64_t num_devices = deviceVec.size();
- llvm::SmallVector arrayPartitionInfoInVec;
- llvm::SmallVector arrayPartitionInfoOutVec;
+ llvm::SmallVector arrayPartitionInfoInVec;
+ llvm::SmallVector arrayPartitionInfoOutVec;
int64_t total_iters = ub - lb;
@@ -227,13 +227,13 @@ struct ConvertReplicateOp : public OpConversionPattern
for (Value memref : insVec)
{
- mlir::avial::ArrayPartitioningAnalysis analysis(outerForOp);
+ mlir::dhir::ArrayPartitioningAnalysis analysis(outerForOp);
arrayPartitionInfoInVec.push_back(analysis.analyzeArray(memref));
}
for (Value memref : outsVec)
{
- mlir::avial::ArrayPartitioningAnalysis analysis(outerForOp);
+ mlir::dhir::ArrayPartitioningAnalysis analysis(outerForOp);
arrayPartitionInfoOutVec.push_back(analysis.analyzeArray(memref));
}
}
@@ -337,14 +337,14 @@ struct ConvertReplicateOp : public OpConversionPattern
mapping.map(out, out);
}
- if (mlir::avial::doesOutputNeedBroadcast(op, out))
+ if (mlir::dhir::doesOutputNeedBroadcast(op, out))
needBroadcast = true;
}
mlir::DenseI64ArrayAttr outRanges = rewriter.getDenseI64ArrayAttr({start, end});
- auto taskOp = rewriter.create(
+ auto taskOp = rewriter.create(
op.getLoc(),
- avial::TaskRefType::get(rewriter.getContext()),
+ dhir::TaskRefType::get(rewriter.getContext()),
deviceVec[i],
ValueRange(subViewIns), rewriter.getDenseI64ArrayAttr({0, 0}),
ValueRange(subViewOuts), outRanges, ValueRange{outsVec});
@@ -457,7 +457,7 @@ struct ConvertReplicateOp : public OpConversionPattern
}
rewriter.setInsertionPointToEnd(&taskOp.getRegion().front());
- rewriter.create(rewriter.getUnknownLoc());
+ rewriter.create(rewriter.getUnknownLoc());
subViewIns.clear();
subViewOuts.clear();
@@ -470,12 +470,12 @@ struct ConvertReplicateOp : public OpConversionPattern
namespace mlir
{
- namespace avial
+ namespace dhir
{
#define GEN_PASS_DEF_LOWERREPLICATEOPPASS
#include "dialect/Passes.h.inc"
struct LowerReplicateOpPass
- : public mlir::avial::impl::LowerReplicateOpPassBase
+ : public mlir::dhir::impl::LowerReplicateOpPassBase
{
using LowerReplicateOpPassBase::LowerReplicateOpPassBase;
@@ -488,15 +488,15 @@ namespace mlir
targetReplicateOp.addLegalDialect();
targetReplicateOp.addLegalDialect();
targetReplicateOp.addLegalDialect();
- targetReplicateOp.addLegalOp();
- targetReplicateOp.addIllegalOp();
- targetReplicateOp.addLegalOp();
+ targetReplicateOp.addLegalOp();
+ targetReplicateOp.addIllegalOp();
+ targetReplicateOp.addLegalOp();
targetReplicateOp.addLegalDialect();
- RewritePatternSet avialpatterns(context);
- avialpatterns.add(context);
+ RewritePatternSet dhirpatterns(context);
+ dhirpatterns.add(context);
- if (failed(applyPartialConversion(module, targetReplicateOp, std::move(avialpatterns))))
+ if (failed(applyPartialConversion(module, targetReplicateOp, std::move(dhirpatterns))))
signalPassFailure();
}
};
diff --git a/conversions/stdtoavial.h b/conversions/stdtodhir.h
similarity index 76%
rename from conversions/stdtoavial.h
rename to conversions/stdtodhir.h
index 78689f9..1bf886d 100644
--- a/conversions/stdtoavial.h
+++ b/conversions/stdtodhir.h
@@ -1,8 +1,8 @@
#include "mlir/Pass/PassManager.h"
#include "mlir/IR/PatternMatch.h"
-#include "includes/avialDialect.h"
-#include "includes/avialTypes.h"
+#include "includes/dhirDialect.h"
+#include "includes/dhirTypes.h"
#include "mlir/Transforms/DialectConversion.h"
@@ -14,9 +14,9 @@
#include "mlir/Dialect/Func/IR/FuncOps.h"
#include "mlir/Dialect/SCF/IR/SCF.h"
-#include "includes/avialDialect.h"
-#include "includes/avialOps.h"
-#include "includes/avialTypes.h"
+#include "includes/dhirDialect.h"
+#include "includes/dhirOps.h"
+#include "includes/dhirTypes.h"
#include "includes/utils.h"
@@ -29,9 +29,9 @@
#include
using namespace mlir;
-using namespace avial;
+using namespace dhir;
-struct ConvertToAvial : public OpConversionPattern
+struct ConvertToDhir : public OpConversionPattern
{
using OpConversionPattern::OpConversionPattern;
@@ -63,7 +63,7 @@ struct ConvertToAvial : public OpConversionPattern
mlir::ArrayAttr insAttr = rewriter.getArrayAttr(argsAttr);
rewriter.setInsertionPoint(op);
- auto schOp = rewriter.create(rewriter.getUnknownLoc(), insAttr, rewriter.getStringAttr(op.getName()));
+ auto schOp = rewriter.create(rewriter.getUnknownLoc(), insAttr, rewriter.getStringAttr(op.getName()));
for (const auto &arg : llvm::enumerate(op.getRegion().getBlocks().front().getArguments()))
{
@@ -88,13 +88,13 @@ struct ConvertToAvial : public OpConversionPattern
auto archVal = rewriter.getStringAttr("sm_61");
auto entry1 = mlir::DataLayoutEntryAttr::get(archAttr, archVal);
auto targetDlti = mlir::TargetDeviceSpecAttr::get(innerop.getContext(), {entry1});
- auto taskOp = rewriter.create(innerop.getLoc(), avial::TaskRefType::get(rewriter.getContext()), targetDlti, mlir::ValueRange{},mlir::DenseI64ArrayAttr{}, mlir::ValueRange{}, mlir::DenseI64ArrayAttr{}, mlir::ValueRange{});
+ auto taskOp = rewriter.create(innerop.getLoc(), dhir::TaskRefType::get(rewriter.getContext()), targetDlti, mlir::ValueRange{},mlir::DenseI64ArrayAttr{}, mlir::ValueRange{}, mlir::DenseI64ArrayAttr{}, mlir::ValueRange{});
rewriter.setInsertionPointToStart(&taskOp.getBodyRegion().getBlocks().front());
innerop.removeAttr("task");
Operation *cloned = rewriter.clone(innerop, mapping);
- rewriter.create(rewriter.getUnknownLoc());
+ rewriter.create(rewriter.getUnknownLoc());
}
else
Operation *cloned = rewriter.clone(innerop, mapping);
@@ -106,7 +106,7 @@ struct ConvertToAvial : public OpConversionPattern
rewriter.setInsertionPointToEnd(&schOp.getBodyRegion().getBlocks().front());
- rewriter.create(rewriter.getUnknownLoc());
+ rewriter.create(rewriter.getUnknownLoc());
rewriter.eraseOp(op);
@@ -118,14 +118,14 @@ struct ConvertToAvial : public OpConversionPattern
namespace mlir
{
- namespace avial
+ namespace dhir
{
-#define GEN_PASS_DEF_CONVERTSTDTOAVIALPASS
+#define GEN_PASS_DEF_CONVERTSTDTODHIRPASS
#include "dialect/Passes.h.inc"
- struct ConvertStdToAvialPass : public mlir::avial::impl::ConvertStdToAvialPassBase
+ struct ConvertStdToDhirPass : public mlir::dhir::impl::ConvertStdToDhirPassBase
{
- using ConvertStdToAvialPassBase::ConvertStdToAvialPassBase;
+ using ConvertStdToDhirPassBase::ConvertStdToDhirPassBase;
void runOnOperation() override
{
mlir::MLIRContext *context = &getContext();
@@ -135,13 +135,13 @@ namespace mlir
ConversionTarget target(getContext());
target.addIllegalOp();
- target.addLegalDialect();
+ target.addLegalDialect();
target.markUnknownOpDynamicallyLegal([](Operation *op) { return true; });
RewritePatternSet patterns(context);
- patterns.add(context);
+ patterns.add(context);
if (failed(applyPartialConversion(module, target, std::move(patterns))))
{
diff --git a/dialect/CMakeLists.txt b/dialect/CMakeLists.txt
index 0a65f83..25737c1 100644
--- a/dialect/CMakeLists.txt
+++ b/dialect/CMakeLists.txt
@@ -1,6 +1,6 @@
-set(LLVM_TARGET_DEFINITIONS avial.td)
-mlir_tablegen(Dialect.h.inc -gen-dialect-decls -dialect=avial)
-mlir_tablegen(Dialect.cpp.inc -gen-dialect-defs -dialect=avial)
+set(LLVM_TARGET_DEFINITIONS dhir.td)
+mlir_tablegen(Dialect.h.inc -gen-dialect-decls -dialect=dhir)
+mlir_tablegen(Dialect.cpp.inc -gen-dialect-defs -dialect=dhir)
mlir_tablegen(Ops.h.inc -gen-op-decls)
mlir_tablegen(Ops.cpp.inc -gen-op-defs)
mlir_tablegen(Types.h.inc -gen-typedef-decls )
@@ -9,5 +9,5 @@ mlir_tablegen(Enums.h.inc -gen-enum-decls)
mlir_tablegen(Enums.cpp.inc -gen-enum-defs)
mlir_tablegen(Passes.h.inc -gen-pass-decls)
-add_public_tablegen_target(MLIRAvialDialectIncGen)
+add_public_tablegen_target(MLIRDhirDialectIncGen)
diff --git a/dialect/avial.td b/dialect/dhir.td
similarity index 71%
rename from dialect/avial.td
rename to dialect/dhir.td
index c5619ab..a0953c1 100644
--- a/dialect/avial.td
+++ b/dialect/dhir.td
@@ -10,10 +10,10 @@ include "mlir/Pass/PassBase.td"
include "passes.td"
-def AvialDialect : Dialect {
+def DhirDialect : Dialect {
let summary = "A sample dialect for understanding";
- let name = "avial";
- let cppNamespace = "mlir::avial";
+ let name = "dhir";
+ let cppNamespace = "mlir::dhir";
let useDefaultTypePrinterParser = 1;
}
@@ -22,17 +22,17 @@ def AvialDialect : Dialect {
-class AvialDialectType traits = []>
- : TypeDef {
+class DhirDialectType traits = []>
+ : TypeDef {
let mnemonic = typeMnemonic;
}
-def TaskRef : AvialDialectType<"TaskRef", "taskref"> {
+def TaskRef : DhirDialectType<"TaskRef", "taskref"> {
let summary = "Task Ref";
}
-def TargetRef : AvialDialectType<"TargetRef", "targetref"> {
+def TargetRef : DhirDialectType<"TargetRef", "targetref"> {
let summary = "Target Ref";
let parameters = (ins StringRefParameter<"arch">:$value);
let assemblyFormat = " `<` $value `>` ";
@@ -44,12 +44,12 @@ def TargetRef : AvialDialectType<"TargetRef", "targetref"> {
// Ops
-class AvialDialectOp : Op
+class DhirDialectOp : Op
{
let summary = "Operation Class";
}
-def TaskOp : Op]>
+def TaskOp : Op]>
{
let summary = "Task Operation";
let arguments = (
@@ -73,7 +73,7 @@ def TaskOp : Op]>
+def ScheduleOp : Op]>
{
let summary = "ScheduleOp";
let regions = (region SizedRegion<1> : $body);
@@ -88,7 +88,7 @@ def ScheduleOp : Op]>
+def ReplicateOp : Op]>
{
let summary = "ReplicateOp";
let arguments = (ins
@@ -98,7 +98,7 @@ def ReplicateOp : Op : $body);
}
-def ConvergeOp : Op]>
+def ConvergeOp : Op]>
{
let summary = "Converge";
let arguments = (ins
@@ -110,12 +110,12 @@ def ConvergeOp : Op
+def YieldOp : Op
{
let summary = "A Terminator";
}
-def TaskGraphOp : AvialDialectOp<"taskGraph">
+def TaskGraphOp : DhirDialectOp<"taskGraph">
{
let summary = "Task Operation";
let results = (outs AnyType);
diff --git a/dialect/passes.td b/dialect/passes.td
index eccfc5d..c56160b 100644
--- a/dialect/passes.td
+++ b/dialect/passes.td
@@ -1,37 +1,37 @@
-def ConvertAvialIRToMPIPass : Pass<"avialir-to-mpi">{
- let summary = "Avial IR to MPI";
+def ConvertDhirToMPIPass : Pass<"dhir-to-mpi">{
+ let summary = "DHIR to MPI";
- let dependentDialects = ["mlir::avial::AvialDialect",
+ let dependentDialects = ["mlir::dhir::DhirDialect",
"::mlir::scf::SCFDialect", "::mlir::memref::MemRefDialect", "mlir::arith::ArithDialect", "mlir::LLVM::LLVMDialect", "mlir::func::FuncDialect", "mlir::mpi::MPIDialect", "mlir::omp::OpenMPDialect"];
}
-def ConvertStdToAvialPass : Pass<"std-to-avialir">{
- let summary = "Standard Dialects to Avial IR";
+def ConvertStdToDhirPass : Pass<"std-to-dhir">{
+ let summary = "Standard Dialects to DHIR";
- let dependentDialects = ["mlir::avial::AvialDialect",
+ let dependentDialects = ["mlir::dhir::DhirDialect",
"::mlir::scf::SCFDialect", "::mlir::memref::MemRefDialect", "mlir::arith::ArithDialect", "mlir::LLVM::LLVMDialect", "mlir::func::FuncDialect", "mlir::mpi::MPIDialect", "mlir::DLTIDialect"];
}
-def ConvertAffineToAvialPass : Pass<"affine-to-avialir">{
- let summary = "Affine Dialects to Avial IR";
+def ConvertAffineToDhirPass : Pass<"affine-to-dhir">{
+ let summary = "Affine Dialects to DHIR";
- let dependentDialects = ["mlir::avial::AvialDialect",
+ let dependentDialects = ["mlir::dhir::DhirDialect",
"mlir::affine::AffineDialect", "mlir::DLTIDialect"];
}
def LowerReplicateOpPass : Pass<"lower-replicate-op">
{
- let summary = "Lower Avial Dialects to Avial";
- let dependentDialects = ["mlir::avial::AvialDialect"];
+ let summary = "Lower Dhir Dialects to Dhir";
+ let dependentDialects = ["mlir::dhir::DhirDialect"];
}
def LowerConvergeOpPass : Pass<"lower-converge-op">
{
let summary = "Lower Converge Op; Basically enable broadcast flag at the end of last set of tasks";
- let dependentDialects = ["mlir::avial::AvialDialect"];
+ let dependentDialects = ["mlir::dhir::DhirDialect"];
}
\ No newline at end of file
diff --git a/genirs/2mm b/genirs/2mm
deleted file mode 100755
index 0f5943d..0000000
Binary files a/genirs/2mm and /dev/null differ
diff --git a/genirs/2mm.ll b/genirs/2mm.ll
index f7d4918..f92497b 100644
--- a/genirs/2mm.ll
+++ b/genirs/2mm.ll
@@ -3,44 +3,65 @@ source_filename = "LLVMDialectModule"
%struct.ident_t = type { i32, i32, i32, i32, ptr }
+@arch_str_3 = internal constant [7 x i8] c"x86_64\00"
+@node_str_3 = internal constant [6 x i8] c"node3\00"
+@arch_str_2 = internal constant [7 x i8] c"x86_64\00"
+@node_str_2 = internal constant [6 x i8] c"node2\00"
+@arch_str_1 = internal constant [7 x i8] c"x86_64\00"
+@node_str_1 = internal constant [6 x i8] c"node1\00"
+@arch_str_0 = internal constant [7 x i8] c"x86_64\00"
+@node_str_0 = internal constant [6 x i8] c"node0\00"
@0 = private unnamed_addr constant [23 x i8] c";unknown;unknown;0;0;;\00", align 1
@1 = private unnamed_addr constant %struct.ident_t { i32 0, i32 2, i32 0, i32 22, ptr @0 }, align 8
@2 = private unnamed_addr constant %struct.ident_t { i32 0, i32 66, i32 0, i32 22, ptr @0 }, align 8
-%struct.ompi_predefined_communicator_t = type opaque
-@ompi_mpi_comm_world = external global %struct.ompi_predefined_communicator_t, align 1
+declare i32 @MPI_Send(ptr, i32, i32, i32, i32, i32)
-declare i32 @MPI_Barrier(i32)
+declare i32 @MPI_Recv(ptr, i32, i32, i32, i32, i32, ptr)
-declare i32 @MPI_Comm_size(i32, ptr)
+declare i32 @MPI_Barrier(i32)
declare i32 @MPI_Comm_rank(i32, ptr)
declare i32 @MPI_Init(ptr, ptr)
+declare ptr @malloc(i64)
+declare void @buildRankNodeMaps(ptr, ptr, ptr)
-define void @testFunc(i32 %0, i32 %1, i32 %2, i32 %3, float %4, float %5, ptr %6, ptr %7, i64 %8, i64 %9, i64 %10, i64 %11, i64 %12, ptr %13, ptr %14, i64 %15, i64 %16, i64 %17, i64 %18, i64 %19, ptr %20, ptr %21, i64 %22, i64 %23, i64 %24, i64 %25, i64 %26, ptr %27, ptr %28, i64 %29, i64 %30, i64 %31, i64 %32, i64 %33, ptr %34, ptr %35, i64 %36, i64 %37, i64 %38, i64 %39, i64 %40) {
- %structArg151 = alloca { ptr, ptr, ptr, ptr }, align 8
- %structArg149 = alloca { ptr, ptr, ptr, ptr }, align 8
- %structArg147 = alloca { ptr, ptr, ptr, ptr }, align 8
+define void @kernel_2mm(i32 %0, i32 %1, i32 %2, i32 %3, float %4, float %5, ptr %6, ptr %7, i64 %8, i64 %9, i64 %10, i64 %11, i64 %12, ptr %13, ptr %14, i64 %15, i64 %16, i64 %17, i64 %18, i64 %19, ptr %20, ptr %21, i64 %22, i64 %23, i64 %24, i64 %25, i64 %26, ptr %27, ptr %28, i64 %29, i64 %30, i64 %31, i64 %32, i64 %33, ptr %34, ptr %35, i64 %36, i64 %37, i64 %38, i64 %39, i64 %40) {
+ %structArg364 = alloca { ptr, ptr, ptr, ptr }, align 8
+ %structArg361 = alloca { ptr, ptr, ptr, ptr }, align 8
+ %structArg358 = alloca { ptr, ptr, ptr, ptr }, align 8
+ %structArg355 = alloca { ptr, ptr, ptr, ptr }, align 8
+ %structArg352 = alloca { ptr, ptr, ptr, ptr }, align 8
+ %structArg349 = alloca { ptr, ptr, ptr, ptr }, align 8
+ %structArg346 = alloca { ptr, ptr, ptr, ptr }, align 8
%structArg = alloca { ptr, ptr, ptr, ptr }, align 8
- %.reloaded143 = alloca { ptr, ptr, i64, [2 x i64], [2 x i64] }, align 8
- %.reloaded144 = alloca float, align 4
- %.reloaded145 = alloca { ptr, ptr, i64, [2 x i64], [2 x i64] }, align 8
- %.reloaded146 = alloca { ptr, ptr, i64, [2 x i64], [2 x i64] }, align 8
- %.reloaded99 = alloca { ptr, ptr, i64, [2 x i64], [2 x i64] }, align 8
- %.reloaded100 = alloca float, align 4
- %.reloaded101 = alloca { ptr, ptr, i64, [2 x i64], [2 x i64] }, align 8
- %.reloaded102 = alloca { ptr, ptr, i64, [2 x i64], [2 x i64] }, align 8
- %.reloaded55 = alloca { ptr, ptr, i64, [2 x i64], [2 x i64] }, align 8
- %.reloaded56 = alloca { ptr, ptr, i64, [2 x i64], [2 x i64] }, align 8
- %.reloaded57 = alloca float, align 4
- %.reloaded58 = alloca { ptr, ptr, i64, [2 x i64], [2 x i64] }, align 8
+ %.reloaded342 = alloca { ptr, ptr, i64, [2 x i64], [2 x i64] }, align 8
+ %.reloaded343 = alloca float, align 4
+ %.reloaded344 = alloca { ptr, ptr, i64, [2 x i64], [2 x i64] }, align 8
+ %.reloaded295 = alloca { ptr, ptr, i64, [2 x i64], [2 x i64] }, align 8
+ %.reloaded296 = alloca float, align 4
+ %.reloaded297 = alloca { ptr, ptr, i64, [2 x i64], [2 x i64] }, align 8
+ %.reloaded248 = alloca { ptr, ptr, i64, [2 x i64], [2 x i64] }, align 8
+ %.reloaded249 = alloca float, align 4
+ %.reloaded250 = alloca { ptr, ptr, i64, [2 x i64], [2 x i64] }, align 8
+ %.reloaded201 = alloca { ptr, ptr, i64, [2 x i64], [2 x i64] }, align 8
+ %.reloaded202 = alloca float, align 4
+ %.reloaded203 = alloca { ptr, ptr, i64, [2 x i64], [2 x i64] }, align 8
+ %.reloaded154 = alloca { ptr, ptr, i64, [2 x i64], [2 x i64] }, align 8
+ %.reloaded155 = alloca { ptr, ptr, i64, [2 x i64], [2 x i64] }, align 8
+ %.reloaded156 = alloca float, align 4
+ %.reloaded107 = alloca { ptr, ptr, i64, [2 x i64], [2 x i64] }, align 8
+ %.reloaded108 = alloca { ptr, ptr, i64, [2 x i64], [2 x i64] }, align 8
+ %.reloaded109 = alloca float, align 4
+ %.reloaded60 = alloca { ptr, ptr, i64, [2 x i64], [2 x i64] }, align 8
+ %.reloaded61 = alloca { ptr, ptr, i64, [2 x i64], [2 x i64] }, align 8
+ %.reloaded62 = alloca float, align 4
%.reloaded = alloca { ptr, ptr, i64, [2 x i64], [2 x i64] }, align 8
- %.reloaded12 = alloca { ptr, ptr, i64, [2 x i64], [2 x i64] }, align 8
- %.reloaded13 = alloca float, align 4
- %.reloaded14 = alloca { ptr, ptr, i64, [2 x i64], [2 x i64] }, align 8
+ %.reloaded15 = alloca { ptr, ptr, i64, [2 x i64], [2 x i64] }, align 8
+ %.reloaded16 = alloca float, align 4
%42 = insertvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } poison, ptr %34, 0
%43 = insertvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } %42, ptr %35, 1
%44 = insertvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } %43, i64 %36, 2
@@ -48,608 +69,2070 @@ define void @testFunc(i32 %0, i32 %1, i32 %2, i32 %3, float %4, float %5, ptr %6
%46 = insertvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } %45, i64 %39, 4, 0
%47 = insertvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } %46, i64 %38, 3, 1
%48 = insertvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } %47, i64 %40, 4, 1
- %49 = insertvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } poison, ptr %27, 0
- %50 = insertvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } %49, ptr %28, 1
- %51 = insertvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } %50, i64 %29, 2
- %52 = insertvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } %51, i64 %30, 3, 0
- %53 = insertvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } %52, i64 %32, 4, 0
- %54 = insertvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } %53, i64 %31, 3, 1
- %55 = insertvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } %54, i64 %33, 4, 1
- %56 = insertvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } poison, ptr %20, 0
- %57 = insertvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } %56, ptr %21, 1
- %58 = insertvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } %57, i64 %22, 2
- %59 = insertvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } %58, i64 %23, 3, 0
- %60 = insertvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } %59, i64 %25, 4, 0
- %61 = insertvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } %60, i64 %24, 3, 1
- %62 = insertvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } %61, i64 %26, 4, 1
- %63 = insertvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } poison, ptr %13, 0
- %64 = insertvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } %63, ptr %14, 1
- %65 = insertvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } %64, i64 %15, 2
- %66 = insertvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } %65, i64 %16, 3, 0
- %67 = insertvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } %66, i64 %18, 4, 0
- %68 = insertvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } %67, i64 %17, 3, 1
- %69 = insertvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } %68, i64 %19, 4, 1
- %70 = insertvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } poison, ptr %6, 0
- %71 = insertvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } %70, ptr %7, 1
- %72 = insertvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } %71, i64 %8, 2
- %73 = insertvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } %72, i64 %9, 3, 0
- %74 = insertvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } %73, i64 %11, 4, 0
- %75 = insertvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } %74, i64 %10, 3, 1
- %76 = insertvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } %75, i64 %12, 4, 1
- ;%77 = call i32 @MPI_Init(ptr null, ptr null)
- %78 = alloca i32, align 4
- %79 = call i32 @MPI_Comm_rank(ptr noundef @ompi_mpi_comm_world, ptr noundef %78)
- %80 = load i32, ptr %78, align 4
- %81 = alloca i32, align 4
- %82 = call i32 @MPI_Comm_size(ptr noundef @ompi_mpi_comm_world, ptr noundef %81)
- %83 = load i32, ptr %81, align 4
- %84 = srem i32 0, %83
- %85 = icmp eq i32 %80, %84
- br i1 %85, label %86, label %87
-
-86: ; preds = %41
+ %49 = insertvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } poison, ptr %13, 0
+ %50 = insertvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } %49, ptr %14, 1
+ %51 = insertvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } %50, i64 %15, 2
+ %52 = insertvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } %51, i64 %16, 3, 0
+ %53 = insertvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } %52, i64 %18, 4, 0
+ %54 = insertvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } %53, i64 %17, 3, 1
+ %55 = insertvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } %54, i64 %19, 4, 1
+ %56 = insertvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } poison, ptr %6, 0
+ %57 = insertvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } %56, ptr %7, 1
+ %58 = insertvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } %57, i64 %8, 2
+ %59 = insertvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } %58, i64 %9, 3, 0
+ %60 = insertvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } %59, i64 %11, 4, 0
+ %61 = insertvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } %60, i64 %10, 3, 1
+ %62 = insertvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } %61, i64 %12, 4, 1
+ %63 = call i32 @MPI_Init(ptr null, ptr null)
+ %64 = alloca i32, align 4
+ %65 = call i32 @MPI_Comm_rank(i32 1140850688, ptr %64)
+ %66 = load i32, ptr %64, align 4
+ %67 = alloca { ptr, ptr, i32, float }, i64 4, align 8
+ %68 = getelementptr { ptr, ptr, i32, float }, ptr %67, i32 0, i32 0
+ %69 = getelementptr { ptr, ptr, i32, float }, ptr %67, i32 0, i32 1
+ %70 = getelementptr { ptr, ptr, i32, float }, ptr %67, i32 0, i32 2
+ %71 = getelementptr { ptr, ptr, i32, float }, ptr %67, i32 0, i32 3
+ store ptr @node_str_0, ptr %68, align 8
+ store ptr @arch_str_0, ptr %69, align 8
+ store i32 0, ptr %70, align 4
+ store float 1.000000e+00, ptr %71, align 4
+ %72 = getelementptr { ptr, ptr, i32, float }, ptr %67, i32 1
+ %73 = getelementptr { ptr, ptr, i32, float }, ptr %72, i32 0, i32 0
+ %74 = getelementptr { ptr, ptr, i32, float }, ptr %72, i32 0, i32 1
+ %75 = getelementptr { ptr, ptr, i32, float }, ptr %72, i32 0, i32 2
+ %76 = getelementptr { ptr, ptr, i32, float }, ptr %72, i32 0, i32 3
+ store ptr @node_str_1, ptr %73, align 8
+ store ptr @arch_str_1, ptr %74, align 8
+ store i32 0, ptr %75, align 4
+ store float 1.000000e+00, ptr %76, align 4
+ %77 = getelementptr { ptr, ptr, i32, float }, ptr %67, i32 2
+ %78 = getelementptr { ptr, ptr, i32, float }, ptr %77, i32 0, i32 0
+ %79 = getelementptr { ptr, ptr, i32, float }, ptr %77, i32 0, i32 1
+ %80 = getelementptr { ptr, ptr, i32, float }, ptr %77, i32 0, i32 2
+ %81 = getelementptr { ptr, ptr, i32, float }, ptr %77, i32 0, i32 3
+ store ptr @node_str_2, ptr %78, align 8
+ store ptr @arch_str_2, ptr %79, align 8
+ store i32 0, ptr %80, align 4
+ store float 1.000000e+00, ptr %81, align 4
+ %82 = getelementptr { ptr, ptr, i32, float }, ptr %67, i32 3
+ %83 = getelementptr { ptr, ptr, i32, float }, ptr %82, i32 0, i32 0
+ %84 = getelementptr { ptr, ptr, i32, float }, ptr %82, i32 0, i32 1
+ %85 = getelementptr { ptr, ptr, i32, float }, ptr %82, i32 0, i32 2
+ %86 = getelementptr { ptr, ptr, i32, float }, ptr %82, i32 0, i32 3
+ store ptr @node_str_3, ptr %83, align 8
+ store ptr @arch_str_3, ptr %84, align 8
+ store i32 0, ptr %85, align 4
+ store float 1.000000e+00, ptr %86, align 4
+ %87 = alloca { i32, ptr }, i64 1, align 8
+ %88 = getelementptr { i32, ptr }, ptr %87, i32 0, i32 0
+ %89 = getelementptr { i32, ptr }, ptr %87, i32 0, i32 1
+ store i32 4, ptr %88, align 4
+ store ptr %67, ptr %89, align 8
+ %90 = call ptr @malloc(i64 16)
+ %91 = call ptr @malloc(i64 16)
+ %92 = ptrtoint ptr %90 to i64
+ %93 = ptrtoint ptr %91 to i64
+ %94 = inttoptr i64 %92 to ptr
+ %95 = inttoptr i64 %93 to ptr
+ call void @buildRankNodeMaps(ptr %87, ptr %94, ptr %95)
+ %96 = sext i32 %66 to i64
+ %97 = getelementptr inbounds nuw i32, ptr %90, i64 %96
+ %98 = load i32, ptr %97, align 4
+ %99 = extractvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } %55, 0
+ %100 = extractvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } %55, 1
+ %101 = insertvalue { ptr, ptr, i64 } poison, ptr %99, 0
+ %102 = insertvalue { ptr, ptr, i64 } %101, ptr %100, 1
+ %103 = insertvalue { ptr, ptr, i64 } %102, i64 0, 2
+ %104 = extractvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } %55, 2
+ %105 = extractvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } %55, 3, 0
+ %106 = extractvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } %55, 3, 1
+ %107 = extractvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } %55, 4, 0
+ %108 = extractvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } %55, 4, 1
+ %109 = extractvalue { ptr, ptr, i64 } %103, 0
+ %110 = extractvalue { ptr, ptr, i64 } %103, 1
+ %111 = insertvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } poison, ptr %109, 0
+ %112 = insertvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } %111, ptr %110, 1
+ %113 = insertvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } %112, i64 0, 2
+ %114 = insertvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } %113, i64 2500, 3, 0
+ %115 = insertvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } %114, i64 10000, 4, 0
+ %116 = insertvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } %115, i64 10000, 3, 1
+ %117 = insertvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } %116, i64 1, 4, 1
+ %118 = extractvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } %62, 0
+ %119 = extractvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } %62, 1
+ %120 = insertvalue { ptr, ptr, i64 } poison, ptr %118, 0
+ %121 = insertvalue { ptr, ptr, i64 } %120, ptr %119, 1
+ %122 = insertvalue { ptr, ptr, i64 } %121, i64 0, 2
+ %123 = extractvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } %62, 2
+ %124 = extractvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } %62, 3, 0
+ %125 = extractvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } %62, 3, 1
+ %126 = extractvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } %62, 4, 0
+ %127 = extractvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } %62, 4, 1
+ %128 = extractvalue { ptr, ptr, i64 } %122, 0
+ %129 = extractvalue { ptr, ptr, i64 } %122, 1
+ %130 = insertvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } poison, ptr %128, 0
+ %131 = insertvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } %130, ptr %129, 1
+ %132 = insertvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } %131, i64 0, 2
+ %133 = insertvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } %132, i64 2500, 3, 0
+ %134 = insertvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } %133, i64 10000, 4, 0
+ %135 = insertvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } %134, i64 10000, 3, 1
+ %136 = insertvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } %135, i64 1, 4, 1
+ %137 = extractvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } %55, 0
+ %138 = extractvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } %55, 1
+ %139 = insertvalue { ptr, ptr, i64 } poison, ptr %137, 0
+ %140 = insertvalue { ptr, ptr, i64 } %139, ptr %138, 1
+ %141 = insertvalue { ptr, ptr, i64 } %140, i64 0, 2
+ %142 = extractvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } %55, 2
+ %143 = extractvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } %55, 3, 0
+ %144 = extractvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } %55, 3, 1
+ %145 = extractvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } %55, 4, 0
+ %146 = extractvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } %55, 4, 1
+ %147 = extractvalue { ptr, ptr, i64 } %141, 0
+ %148 = extractvalue { ptr, ptr, i64 } %141, 1
+ %149 = insertvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } poison, ptr %147, 0
+ %150 = insertvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } %149, ptr %148, 1
+ %151 = insertvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } %150, i64 25000000, 2
+ %152 = insertvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } %151, i64 2500, 3, 0
+ %153 = insertvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } %152, i64 10000, 4, 0
+ %154 = insertvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } %153, i64 10000, 3, 1
+ %155 = insertvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } %154, i64 1, 4, 1
+ %156 = extractvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } %62, 0
+ %157 = extractvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } %62, 1
+ %158 = insertvalue { ptr, ptr, i64 } poison, ptr %156, 0
+ %159 = insertvalue { ptr, ptr, i64 } %158, ptr %157, 1
+ %160 = insertvalue { ptr, ptr, i64 } %159, i64 0, 2
+ %161 = extractvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } %62, 2
+ %162 = extractvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } %62, 3, 0
+ %163 = extractvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } %62, 3, 1
+ %164 = extractvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } %62, 4, 0
+ %165 = extractvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } %62, 4, 1
+ %166 = extractvalue { ptr, ptr, i64 } %160, 0
+ %167 = extractvalue { ptr, ptr, i64 } %160, 1
+ %168 = insertvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } poison, ptr %166, 0
+ %169 = insertvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } %168, ptr %167, 1
+ %170 = insertvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } %169, i64 25000000, 2
+ %171 = insertvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } %170, i64 2500, 3, 0
+ %172 = insertvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } %171, i64 10000, 4, 0
+ %173 = insertvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } %172, i64 10000, 3, 1
+ %174 = insertvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } %173, i64 1, 4, 1
+ %175 = extractvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } %55, 0
+ %176 = extractvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } %55, 1
+ %177 = insertvalue { ptr, ptr, i64 } poison, ptr %175, 0
+ %178 = insertvalue { ptr, ptr, i64 } %177, ptr %176, 1
+ %179 = insertvalue { ptr, ptr, i64 } %178, i64 0, 2
+ %180 = extractvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } %55, 2
+ %181 = extractvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } %55, 3, 0
+ %182 = extractvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } %55, 3, 1
+ %183 = extractvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } %55, 4, 0
+ %184 = extractvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } %55, 4, 1
+ %185 = extractvalue { ptr, ptr, i64 } %179, 0
+ %186 = extractvalue { ptr, ptr, i64 } %179, 1
+ %187 = insertvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } poison, ptr %185, 0
+ %188 = insertvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } %187, ptr %186, 1
+ %189 = insertvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } %188, i64 50000000, 2
+ %190 = insertvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } %189, i64 2500, 3, 0
+ %191 = insertvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } %190, i64 10000, 4, 0
+ %192 = insertvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } %191, i64 10000, 3, 1
+ %193 = insertvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } %192, i64 1, 4, 1
+ %194 = extractvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } %62, 0
+ %195 = extractvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } %62, 1
+ %196 = insertvalue { ptr, ptr, i64 } poison, ptr %194, 0
+ %197 = insertvalue { ptr, ptr, i64 } %196, ptr %195, 1
+ %198 = insertvalue { ptr, ptr, i64 } %197, i64 0, 2
+ %199 = extractvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } %62, 2
+ %200 = extractvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } %62, 3, 0
+ %201 = extractvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } %62, 3, 1
+ %202 = extractvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } %62, 4, 0
+ %203 = extractvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } %62, 4, 1
+ %204 = extractvalue { ptr, ptr, i64 } %198, 0
+ %205 = extractvalue { ptr, ptr, i64 } %198, 1
+ %206 = insertvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } poison, ptr %204, 0
+ %207 = insertvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } %206, ptr %205, 1
+ %208 = insertvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } %207, i64 50000000, 2
+ %209 = insertvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } %208, i64 2500, 3, 0
+ %210 = insertvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } %209, i64 10000, 4, 0
+ %211 = insertvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } %210, i64 10000, 3, 1
+ %212 = insertvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } %211, i64 1, 4, 1
+ %213 = extractvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } %55, 0
+ %214 = extractvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } %55, 1
+ %215 = insertvalue { ptr, ptr, i64 } poison, ptr %213, 0
+ %216 = insertvalue { ptr, ptr, i64 } %215, ptr %214, 1
+ %217 = insertvalue { ptr, ptr, i64 } %216, i64 0, 2
+ %218 = extractvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } %55, 2
+ %219 = extractvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } %55, 3, 0
+ %220 = extractvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } %55, 3, 1
+ %221 = extractvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } %55, 4, 0
+ %222 = extractvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } %55, 4, 1
+ %223 = extractvalue { ptr, ptr, i64 } %217, 0
+ %224 = extractvalue { ptr, ptr, i64 } %217, 1
+ %225 = insertvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } poison, ptr %223, 0
+ %226 = insertvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } %225, ptr %224, 1
+ %227 = insertvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } %226, i64 75000000, 2
+ %228 = insertvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } %227, i64 2500, 3, 0
+ %229 = insertvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } %228, i64 10000, 4, 0
+ %230 = insertvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } %229, i64 10000, 3, 1
+ %231 = insertvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } %230, i64 1, 4, 1
+ %232 = extractvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } %62, 0
+ %233 = extractvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } %62, 1
+ %234 = insertvalue { ptr, ptr, i64 } poison, ptr %232, 0
+ %235 = insertvalue { ptr, ptr, i64 } %234, ptr %233, 1
+ %236 = insertvalue { ptr, ptr, i64 } %235, i64 0, 2
+ %237 = extractvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } %62, 2
+ %238 = extractvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } %62, 3, 0
+ %239 = extractvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } %62, 3, 1
+ %240 = extractvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } %62, 4, 0
+ %241 = extractvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } %62, 4, 1
+ %242 = extractvalue { ptr, ptr, i64 } %236, 0
+ %243 = extractvalue { ptr, ptr, i64 } %236, 1
+ %244 = insertvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } poison, ptr %242, 0
+ %245 = insertvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } %244, ptr %243, 1
+ %246 = insertvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } %245, i64 75000000, 2
+ %247 = insertvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } %246, i64 2500, 3, 0
+ %248 = insertvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } %247, i64 10000, 4, 0
+ %249 = insertvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } %248, i64 10000, 3, 1
+ %250 = insertvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } %249, i64 1, 4, 1
+ %251 = extractvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } %62, 0
+ %252 = extractvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } %62, 1
+ %253 = insertvalue { ptr, ptr, i64 } poison, ptr %251, 0
+ %254 = insertvalue { ptr, ptr, i64 } %253, ptr %252, 1
+ %255 = insertvalue { ptr, ptr, i64 } %254, i64 0, 2
+ %256 = extractvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } %62, 2
+ %257 = extractvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } %62, 3, 0
+ %258 = extractvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } %62, 3, 1
+ %259 = extractvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } %62, 4, 0
+ %260 = extractvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } %62, 4, 1
+ %261 = extractvalue { ptr, ptr, i64 } %255, 0
+ %262 = extractvalue { ptr, ptr, i64 } %255, 1
+ %263 = insertvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } poison, ptr %261, 0
+ %264 = insertvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } %263, ptr %262, 1
+ %265 = insertvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } %264, i64 0, 2
+ %266 = insertvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } %265, i64 2500, 3, 0
+ %267 = insertvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } %266, i64 10000, 4, 0
+ %268 = insertvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } %267, i64 10000, 3, 1
+ %269 = insertvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } %268, i64 1, 4, 1
+ %270 = extractvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } %48, 0
+ %271 = extractvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } %48, 1
+ %272 = insertvalue { ptr, ptr, i64 } poison, ptr %270, 0
+ %273 = insertvalue { ptr, ptr, i64 } %272, ptr %271, 1
+ %274 = insertvalue { ptr, ptr, i64 } %273, i64 0, 2
+ %275 = extractvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } %48, 2
+ %276 = extractvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } %48, 3, 0
+ %277 = extractvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } %48, 3, 1
+ %278 = extractvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } %48, 4, 0
+ %279 = extractvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } %48, 4, 1
+ %280 = extractvalue { ptr, ptr, i64 } %274, 0
+ %281 = extractvalue { ptr, ptr, i64 } %274, 1
+ %282 = insertvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } poison, ptr %280, 0
+ %283 = insertvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } %282, ptr %281, 1
+ %284 = insertvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } %283, i64 0, 2
+ %285 = insertvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } %284, i64 2500, 3, 0
+ %286 = insertvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } %285, i64 10000, 4, 0
+ %287 = insertvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } %286, i64 10000, 3, 1
+ %288 = insertvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } %287, i64 1, 4, 1
+ %289 = extractvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } %62, 0
+ %290 = extractvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } %62, 1
+ %291 = insertvalue { ptr, ptr, i64 } poison, ptr %289, 0
+ %292 = insertvalue { ptr, ptr, i64 } %291, ptr %290, 1
+ %293 = insertvalue { ptr, ptr, i64 } %292, i64 0, 2
+ %294 = extractvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } %62, 2
+ %295 = extractvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } %62, 3, 0
+ %296 = extractvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } %62, 3, 1
+ %297 = extractvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } %62, 4, 0
+ %298 = extractvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } %62, 4, 1
+ %299 = extractvalue { ptr, ptr, i64 } %293, 0
+ %300 = extractvalue { ptr, ptr, i64 } %293, 1
+ %301 = insertvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } poison, ptr %299, 0
+ %302 = insertvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } %301, ptr %300, 1
+ %303 = insertvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } %302, i64 25000000, 2
+ %304 = insertvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } %303, i64 2500, 3, 0
+ %305 = insertvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } %304, i64 10000, 4, 0
+ %306 = insertvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } %305, i64 10000, 3, 1
+ %307 = insertvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } %306, i64 1, 4, 1
+ %308 = extractvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } %48, 0
+ %309 = extractvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } %48, 1
+ %310 = insertvalue { ptr, ptr, i64 } poison, ptr %308, 0
+ %311 = insertvalue { ptr, ptr, i64 } %310, ptr %309, 1
+ %312 = insertvalue { ptr, ptr, i64 } %311, i64 0, 2
+ %313 = extractvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } %48, 2
+ %314 = extractvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } %48, 3, 0
+ %315 = extractvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } %48, 3, 1
+ %316 = extractvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } %48, 4, 0
+ %317 = extractvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } %48, 4, 1
+ %318 = extractvalue { ptr, ptr, i64 } %312, 0
+ %319 = extractvalue { ptr, ptr, i64 } %312, 1
+ %320 = insertvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } poison, ptr %318, 0
+ %321 = insertvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } %320, ptr %319, 1
+ %322 = insertvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } %321, i64 25000000, 2
+ %323 = insertvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } %322, i64 2500, 3, 0
+ %324 = insertvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } %323, i64 10000, 4, 0
+ %325 = insertvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } %324, i64 10000, 3, 1
+ %326 = insertvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } %325, i64 1, 4, 1
+ %327 = extractvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } %62, 0
+ %328 = extractvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } %62, 1
+ %329 = insertvalue { ptr, ptr, i64 } poison, ptr %327, 0
+ %330 = insertvalue { ptr, ptr, i64 } %329, ptr %328, 1
+ %331 = insertvalue { ptr, ptr, i64 } %330, i64 0, 2
+ %332 = extractvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } %62, 2
+ %333 = extractvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } %62, 3, 0
+ %334 = extractvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } %62, 3, 1
+ %335 = extractvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } %62, 4, 0
+ %336 = extractvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } %62, 4, 1
+ %337 = extractvalue { ptr, ptr, i64 } %331, 0
+ %338 = extractvalue { ptr, ptr, i64 } %331, 1
+ %339 = insertvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } poison, ptr %337, 0
+ %340 = insertvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } %339, ptr %338, 1
+ %341 = insertvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } %340, i64 50000000, 2
+ %342 = insertvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } %341, i64 2500, 3, 0
+ %343 = insertvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } %342, i64 10000, 4, 0
+ %344 = insertvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } %343, i64 10000, 3, 1
+ %345 = insertvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } %344, i64 1, 4, 1
+ %346 = extractvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } %48, 0
+ %347 = extractvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } %48, 1
+ %348 = insertvalue { ptr, ptr, i64 } poison, ptr %346, 0
+ %349 = insertvalue { ptr, ptr, i64 } %348, ptr %347, 1
+ %350 = insertvalue { ptr, ptr, i64 } %349, i64 0, 2
+ %351 = extractvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } %48, 2
+ %352 = extractvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } %48, 3, 0
+ %353 = extractvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } %48, 3, 1
+ %354 = extractvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } %48, 4, 0
+ %355 = extractvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } %48, 4, 1
+ %356 = extractvalue { ptr, ptr, i64 } %350, 0
+ %357 = extractvalue { ptr, ptr, i64 } %350, 1
+ %358 = insertvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } poison, ptr %356, 0
+ %359 = insertvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } %358, ptr %357, 1
+ %360 = insertvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } %359, i64 50000000, 2
+ %361 = insertvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } %360, i64 2500, 3, 0
+ %362 = insertvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } %361, i64 10000, 4, 0
+ %363 = insertvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } %362, i64 10000, 3, 1
+ %364 = insertvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } %363, i64 1, 4, 1
+ %365 = extractvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } %62, 0
+ %366 = extractvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } %62, 1
+ %367 = insertvalue { ptr, ptr, i64 } poison, ptr %365, 0
+ %368 = insertvalue { ptr, ptr, i64 } %367, ptr %366, 1
+ %369 = insertvalue { ptr, ptr, i64 } %368, i64 0, 2
+ %370 = extractvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } %62, 2
+ %371 = extractvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } %62, 3, 0
+ %372 = extractvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } %62, 3, 1
+ %373 = extractvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } %62, 4, 0
+ %374 = extractvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } %62, 4, 1
+ %375 = extractvalue { ptr, ptr, i64 } %369, 0
+ %376 = extractvalue { ptr, ptr, i64 } %369, 1
+ %377 = insertvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } poison, ptr %375, 0
+ %378 = insertvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } %377, ptr %376, 1
+ %379 = insertvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } %378, i64 75000000, 2
+ %380 = insertvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } %379, i64 2500, 3, 0
+ %381 = insertvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } %380, i64 10000, 4, 0
+ %382 = insertvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } %381, i64 10000, 3, 1
+ %383 = insertvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } %382, i64 1, 4, 1
+ %384 = extractvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } %48, 0
+ %385 = extractvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } %48, 1
+ %386 = insertvalue { ptr, ptr, i64 } poison, ptr %384, 0
+ %387 = insertvalue { ptr, ptr, i64 } %386, ptr %385, 1
+ %388 = insertvalue { ptr, ptr, i64 } %387, i64 0, 2
+ %389 = extractvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } %48, 2
+ %390 = extractvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } %48, 3, 0
+ %391 = extractvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } %48, 3, 1
+ %392 = extractvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } %48, 4, 0
+ %393 = extractvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } %48, 4, 1
+ %394 = extractvalue { ptr, ptr, i64 } %388, 0
+ %395 = extractvalue { ptr, ptr, i64 } %388, 1
+ %396 = insertvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } poison, ptr %394, 0
+ %397 = insertvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } %396, ptr %395, 1
+ %398 = insertvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } %397, i64 75000000, 2
+ %399 = insertvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } %398, i64 2500, 3, 0
+ %400 = insertvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } %399, i64 10000, 4, 0
+ %401 = insertvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } %400, i64 10000, 3, 1
+ %402 = insertvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } %401, i64 1, 4, 1
+ %403 = icmp eq i32 %98, 0
+ br i1 %403, label %404, label %405
+
+404: ; preds = %41
%omp_global_thread_num = call i32 @__kmpc_global_thread_num(ptr @1)
- store { ptr, ptr, i64, [2 x i64], [2 x i64] } %76, ptr %.reloaded, align 8
- store { ptr, ptr, i64, [2 x i64], [2 x i64] } %69, ptr %.reloaded12, align 8
- store float %4, ptr %.reloaded13, align 4
- store { ptr, ptr, i64, [2 x i64], [2 x i64] } %62, ptr %.reloaded14, align 8
+ store { ptr, ptr, i64, [2 x i64], [2 x i64] } %136, ptr %.reloaded, align 8
+ store { ptr, ptr, i64, [2 x i64], [2 x i64] } %117, ptr %.reloaded15, align 8
+ store float %4, ptr %.reloaded16, align 4
br label %omp_parallel
-omp_parallel: ; preds = %86
+omp_parallel: ; preds = %404
%gep_.reloaded = getelementptr { ptr, ptr, ptr, ptr }, ptr %structArg, i32 0, i32 0
store ptr %.reloaded, ptr %gep_.reloaded, align 8
- %gep_.reloaded12 = getelementptr { ptr, ptr, ptr, ptr }, ptr %structArg, i32 0, i32 1
- store ptr %.reloaded12, ptr %gep_.reloaded12, align 8
- %gep_.reloaded13 = getelementptr { ptr, ptr, ptr, ptr }, ptr %structArg, i32 0, i32 2
- store ptr %.reloaded13, ptr %gep_.reloaded13, align 8
- %gep_.reloaded14 = getelementptr { ptr, ptr, ptr, ptr }, ptr %structArg, i32 0, i32 3
- store ptr %.reloaded14, ptr %gep_.reloaded14, align 8
- call void (ptr, i32, ptr, ...) @__kmpc_fork_call(ptr @1, i32 1, ptr @testFunc..omp_par, ptr %structArg)
- br label %omp.par.outlined.exit
-
-omp.par.outlined.exit: ; preds = %omp_parallel
- br label %omp.par.exit.split
-
-omp.par.exit.split: ; preds = %omp.par.outlined.exit
- br label %87
-
-87: ; preds = %omp.par.exit.split, %41
- %88 = srem i32 1, %83
- %89 = icmp eq i32 %80, %88
- br i1 %89, label %90, label %91
-
-90: ; preds = %87
- %omp_global_thread_num15 = call i32 @__kmpc_global_thread_num(ptr @1)
- store { ptr, ptr, i64, [2 x i64], [2 x i64] } %76, ptr %.reloaded55, align 8
- store { ptr, ptr, i64, [2 x i64], [2 x i64] } %69, ptr %.reloaded56, align 8
- store float %4, ptr %.reloaded57, align 4
- store { ptr, ptr, i64, [2 x i64], [2 x i64] } %62, ptr %.reloaded58, align 8
- br label %omp_parallel148
-
-omp_parallel148: ; preds = %90
- %gep_.reloaded55 = getelementptr { ptr, ptr, ptr, ptr }, ptr %structArg147, i32 0, i32 0
- store ptr %.reloaded55, ptr %gep_.reloaded55, align 8
- %gep_.reloaded56 = getelementptr { ptr, ptr, ptr, ptr }, ptr %structArg147, i32 0, i32 1
- store ptr %.reloaded56, ptr %gep_.reloaded56, align 8
- %gep_.reloaded57 = getelementptr { ptr, ptr, ptr, ptr }, ptr %structArg147, i32 0, i32 2
- store ptr %.reloaded57, ptr %gep_.reloaded57, align 8
- %gep_.reloaded58 = getelementptr { ptr, ptr, ptr, ptr }, ptr %structArg147, i32 0, i32 3
- store ptr %.reloaded58, ptr %gep_.reloaded58, align 8
- call void (ptr, i32, ptr, ...) @__kmpc_fork_call(ptr @1, i32 1, ptr @testFunc..omp_par.1, ptr %structArg147)
- br label %omp.par.outlined.exit54
-
-omp.par.outlined.exit54: ; preds = %omp_parallel148
- br label %omp.par.exit.split53
-
-omp.par.exit.split53: ; preds = %omp.par.outlined.exit54
- br label %91
-
-91: ; preds = %omp.par.exit.split53, %87
- %92 = srem i32 2, %83
- %93 = icmp eq i32 %80, %92
- br i1 %93, label %94, label %95
-
-94: ; preds = %91
- %omp_global_thread_num59 = call i32 @__kmpc_global_thread_num(ptr @1)
- store { ptr, ptr, i64, [2 x i64], [2 x i64] } %48, ptr %.reloaded99, align 8
- store float %5, ptr %.reloaded100, align 4
- store { ptr, ptr, i64, [2 x i64], [2 x i64] } %76, ptr %.reloaded101, align 8
- store { ptr, ptr, i64, [2 x i64], [2 x i64] } %55, ptr %.reloaded102, align 8
- br label %omp_parallel150
-
-omp_parallel150: ; preds = %94
- %gep_.reloaded99 = getelementptr { ptr, ptr, ptr, ptr }, ptr %structArg149, i32 0, i32 0
- store ptr %.reloaded99, ptr %gep_.reloaded99, align 8
- %gep_.reloaded100 = getelementptr { ptr, ptr, ptr, ptr }, ptr %structArg149, i32 0, i32 1
- store ptr %.reloaded100, ptr %gep_.reloaded100, align 8
- %gep_.reloaded101 = getelementptr { ptr, ptr, ptr, ptr }, ptr %structArg149, i32 0, i32 2
- store ptr %.reloaded101, ptr %gep_.reloaded101, align 8
- %gep_.reloaded102 = getelementptr { ptr, ptr, ptr, ptr }, ptr %structArg149, i32 0, i32 3
- store ptr %.reloaded102, ptr %gep_.reloaded102, align 8
- call void (ptr, i32, ptr, ...) @__kmpc_fork_call(ptr @1, i32 1, ptr @testFunc..omp_par.2, ptr %structArg149)
- br label %omp.par.outlined.exit98
-
-omp.par.outlined.exit98: ; preds = %omp_parallel150
- br label %omp.par.exit.split97
-
-omp.par.exit.split97: ; preds = %omp.par.outlined.exit98
- br label %95
-
-95: ; preds = %omp.par.exit.split97, %91
- %96 = srem i32 3, %83
- %97 = icmp eq i32 %80, %96
- br i1 %97, label %98, label %99
-
-98: ; preds = %95
- %omp_global_thread_num103 = call i32 @__kmpc_global_thread_num(ptr @1)
- store { ptr, ptr, i64, [2 x i64], [2 x i64] } %48, ptr %.reloaded143, align 8
- store float %5, ptr %.reloaded144, align 4
- store { ptr, ptr, i64, [2 x i64], [2 x i64] } %76, ptr %.reloaded145, align 8
- store { ptr, ptr, i64, [2 x i64], [2 x i64] } %55, ptr %.reloaded146, align 8
- br label %omp_parallel152
-
-omp_parallel152: ; preds = %98
- %gep_.reloaded143 = getelementptr { ptr, ptr, ptr, ptr }, ptr %structArg151, i32 0, i32 0
- store ptr %.reloaded143, ptr %gep_.reloaded143, align 8
- %gep_.reloaded144 = getelementptr { ptr, ptr, ptr, ptr }, ptr %structArg151, i32 0, i32 1
- store ptr %.reloaded144, ptr %gep_.reloaded144, align 8
- %gep_.reloaded145 = getelementptr { ptr, ptr, ptr, ptr }, ptr %structArg151, i32 0, i32 2
- store ptr %.reloaded145, ptr %gep_.reloaded145, align 8
- %gep_.reloaded146 = getelementptr { ptr, ptr, ptr, ptr }, ptr %structArg151, i32 0, i32 3
- store ptr %.reloaded146, ptr %gep_.reloaded146, align 8
- call void (ptr, i32, ptr, ...) @__kmpc_fork_call(ptr @1, i32 1, ptr @testFunc..omp_par.3, ptr %structArg151)
- br label %omp.par.outlined.exit142
-
-omp.par.outlined.exit142: ; preds = %omp_parallel152
- br label %omp.par.exit.split141
-
-omp.par.exit.split141: ; preds = %omp.par.outlined.exit142
- br label %99
-
-99: ; preds = %omp.par.exit.split141, %95
- %100 = call i32 @MPI_Barrier(ptr noundef @ompi_mpi_comm_world)
+ %gep_.reloaded15 = getelementptr { ptr, ptr, ptr, ptr }, ptr %structArg, i32 0, i32 1
+ store ptr %.reloaded15, ptr %gep_.reloaded15, align 8
+ %gep_.reloaded16 = getelementptr { ptr, ptr, ptr, ptr }, ptr %structArg, i32 0, i32 2
+ store ptr %.reloaded16, ptr %gep_.reloaded16, align 8
+ %gep_ = getelementptr { ptr, ptr, ptr, ptr }, ptr %structArg, i32 0, i32 3
+ store ptr %21, ptr %gep_, align 8
+ call void (ptr, i32, ptr, ...) @__kmpc_fork_call(ptr @1, i32 1, ptr @kernel_2mm..omp_par, ptr %structArg)
+ br label %omp.par.exit
+
+omp.par.exit: ; preds = %omp_parallel
+ br label %405
+
+405: ; preds = %omp.par.exit, %41
+ %406 = icmp eq i32 %98, 1
+ br i1 %406, label %407, label %408
+
+407: ; preds = %405
+ %omp_global_thread_num17 = call i32 @__kmpc_global_thread_num(ptr @1)
+ store { ptr, ptr, i64, [2 x i64], [2 x i64] } %174, ptr %.reloaded60, align 8
+ store { ptr, ptr, i64, [2 x i64], [2 x i64] } %155, ptr %.reloaded61, align 8
+ store float %4, ptr %.reloaded62, align 4
+ br label %omp_parallel348
+
+omp_parallel348: ; preds = %407
+ %gep_.reloaded60 = getelementptr { ptr, ptr, ptr, ptr }, ptr %structArg346, i32 0, i32 0
+ store ptr %.reloaded60, ptr %gep_.reloaded60, align 8
+ %gep_.reloaded61 = getelementptr { ptr, ptr, ptr, ptr }, ptr %structArg346, i32 0, i32 1
+ store ptr %.reloaded61, ptr %gep_.reloaded61, align 8
+ %gep_.reloaded62 = getelementptr { ptr, ptr, ptr, ptr }, ptr %structArg346, i32 0, i32 2
+ store ptr %.reloaded62, ptr %gep_.reloaded62, align 8
+ %gep_347 = getelementptr { ptr, ptr, ptr, ptr }, ptr %structArg346, i32 0, i32 3
+ store ptr %21, ptr %gep_347, align 8
+ call void (ptr, i32, ptr, ...) @__kmpc_fork_call(ptr @1, i32 1, ptr @kernel_2mm..omp_par.1, ptr %structArg346)
+ br label %omp.par.exit23
+
+omp.par.exit23: ; preds = %omp_parallel348
+ br label %408
+
+408: ; preds = %omp.par.exit23, %405
+ %409 = icmp eq i32 %98, 2
+ br i1 %409, label %410, label %411
+
+410: ; preds = %408
+ %omp_global_thread_num64 = call i32 @__kmpc_global_thread_num(ptr @1)
+ store { ptr, ptr, i64, [2 x i64], [2 x i64] } %212, ptr %.reloaded107, align 8
+ store { ptr, ptr, i64, [2 x i64], [2 x i64] } %193, ptr %.reloaded108, align 8
+ store float %4, ptr %.reloaded109, align 4
+ br label %omp_parallel351
+
+omp_parallel351: ; preds = %410
+ %gep_.reloaded107 = getelementptr { ptr, ptr, ptr, ptr }, ptr %structArg349, i32 0, i32 0
+ store ptr %.reloaded107, ptr %gep_.reloaded107, align 8
+ %gep_.reloaded108 = getelementptr { ptr, ptr, ptr, ptr }, ptr %structArg349, i32 0, i32 1
+ store ptr %.reloaded108, ptr %gep_.reloaded108, align 8
+ %gep_.reloaded109 = getelementptr { ptr, ptr, ptr, ptr }, ptr %structArg349, i32 0, i32 2
+ store ptr %.reloaded109, ptr %gep_.reloaded109, align 8
+ %gep_350 = getelementptr { ptr, ptr, ptr, ptr }, ptr %structArg349, i32 0, i32 3
+ store ptr %21, ptr %gep_350, align 8
+ call void (ptr, i32, ptr, ...) @__kmpc_fork_call(ptr @1, i32 1, ptr @kernel_2mm..omp_par.2, ptr %structArg349)
+ br label %omp.par.exit70
+
+omp.par.exit70: ; preds = %omp_parallel351
+ br label %411
+
+411: ; preds = %omp.par.exit70, %408
+ %412 = icmp eq i32 %98, 3
+ br i1 %412, label %413, label %414
+
+413: ; preds = %411
+ %omp_global_thread_num111 = call i32 @__kmpc_global_thread_num(ptr @1)
+ store { ptr, ptr, i64, [2 x i64], [2 x i64] } %250, ptr %.reloaded154, align 8
+ store { ptr, ptr, i64, [2 x i64], [2 x i64] } %231, ptr %.reloaded155, align 8
+ store float %4, ptr %.reloaded156, align 4
+ br label %omp_parallel354
+
+omp_parallel354: ; preds = %413
+ %gep_.reloaded154 = getelementptr { ptr, ptr, ptr, ptr }, ptr %structArg352, i32 0, i32 0
+ store ptr %.reloaded154, ptr %gep_.reloaded154, align 8
+ %gep_.reloaded155 = getelementptr { ptr, ptr, ptr, ptr }, ptr %structArg352, i32 0, i32 1
+ store ptr %.reloaded155, ptr %gep_.reloaded155, align 8
+ %gep_.reloaded156 = getelementptr { ptr, ptr, ptr, ptr }, ptr %structArg352, i32 0, i32 2
+ store ptr %.reloaded156, ptr %gep_.reloaded156, align 8
+ %gep_353 = getelementptr { ptr, ptr, ptr, ptr }, ptr %structArg352, i32 0, i32 3
+ store ptr %21, ptr %gep_353, align 8
+ call void (ptr, i32, ptr, ...) @__kmpc_fork_call(ptr @1, i32 1, ptr @kernel_2mm..omp_par.3, ptr %structArg352)
+ br label %omp.par.exit117
+
+omp.par.exit117: ; preds = %omp_parallel354
+ br label %414
+
+414: ; preds = %omp.par.exit117, %411
+ %415 = call i32 @MPI_Barrier(i32 1140850688)
+ %416 = extractvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } %62, 0
+ %417 = extractvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } %62, 1
+ %418 = insertvalue { ptr, ptr, i64 } poison, ptr %416, 0
+ %419 = insertvalue { ptr, ptr, i64 } %418, ptr %417, 1
+ %420 = insertvalue { ptr, ptr, i64 } %419, i64 0, 2
+ %421 = extractvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } %62, 2
+ %422 = extractvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } %62, 3, 0
+ %423 = extractvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } %62, 3, 1
+ %424 = extractvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } %62, 4, 0
+ %425 = extractvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } %62, 4, 1
+ %426 = extractvalue { ptr, ptr, i64 } %420, 0
+ %427 = extractvalue { ptr, ptr, i64 } %420, 1
+ %428 = insertvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } poison, ptr %426, 0
+ %429 = insertvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } %428, ptr %427, 1
+ %430 = insertvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } %429, i64 25000000, 2
+ %431 = insertvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } %430, i64 2500, 3, 0
+ %432 = insertvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } %431, i64 10000, 4, 0
+ %433 = insertvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } %432, i64 10000, 3, 1
+ %434 = insertvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } %433, i64 1, 4, 1
+ %435 = load i32, ptr %91, align 4
+ %436 = getelementptr inbounds nuw i32, ptr %91, i32 1
+ %437 = load i32, ptr %436, align 4
+ %438 = icmp eq i32 %66, %435
+ %439 = icmp eq i32 %66, %437
+ br i1 %438, label %440, label %447
+
+440: ; preds = %414
+ %441 = extractvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } %434, 1
+ %442 = extractvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } %434, 2
+ %443 = getelementptr float, ptr %441, i64 %442
+ %444 = extractvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } %434, 3, 0
+ %445 = trunc i64 %444 to i32
+ %446 = call i32 @MPI_Recv(ptr %443, i32 %445, i32 1275069450, i32 %437, i32 0, i32 1140850688, ptr inttoptr (i64 1 to ptr))
+ br label %456
+
+447: ; preds = %414
+ br i1 %439, label %448, label %455
+
+448: ; preds = %447
+ %449 = extractvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } %434, 1
+ %450 = extractvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } %434, 2
+ %451 = getelementptr float, ptr %449, i64 %450
+ %452 = extractvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } %434, 3, 0
+ %453 = trunc i64 %452 to i32
+ %454 = call i32 @MPI_Send(ptr %451, i32 %453, i32 1275069450, i32 %435, i32 0, i32 1140850688)
+ br label %455
+
+455: ; preds = %448, %447
+ br label %456
+
+456: ; preds = %440, %455
+ %457 = extractvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } %62, 0
+ %458 = extractvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } %62, 1
+ %459 = insertvalue { ptr, ptr, i64 } poison, ptr %457, 0
+ %460 = insertvalue { ptr, ptr, i64 } %459, ptr %458, 1
+ %461 = insertvalue { ptr, ptr, i64 } %460, i64 0, 2
+ %462 = extractvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } %62, 2
+ %463 = extractvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } %62, 3, 0
+ %464 = extractvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } %62, 3, 1
+ %465 = extractvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } %62, 4, 0
+ %466 = extractvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } %62, 4, 1
+ %467 = extractvalue { ptr, ptr, i64 } %461, 0
+ %468 = extractvalue { ptr, ptr, i64 } %461, 1
+ %469 = insertvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } poison, ptr %467, 0
+ %470 = insertvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } %469, ptr %468, 1
+ %471 = insertvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } %470, i64 50000000, 2
+ %472 = insertvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } %471, i64 2500, 3, 0
+ %473 = insertvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } %472, i64 10000, 4, 0
+ %474 = insertvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } %473, i64 10000, 3, 1
+ %475 = insertvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } %474, i64 1, 4, 1
+ %476 = load i32, ptr %91, align 4
+ %477 = getelementptr inbounds nuw i32, ptr %91, i32 2
+ %478 = load i32, ptr %477, align 4
+ %479 = icmp eq i32 %66, %476
+ %480 = icmp eq i32 %66, %478
+ br i1 %479, label %481, label %488
+
+481: ; preds = %456
+ %482 = extractvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } %475, 1
+ %483 = extractvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } %475, 2
+ %484 = getelementptr float, ptr %482, i64 %483
+ %485 = extractvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } %475, 3, 0
+ %486 = trunc i64 %485 to i32
+ %487 = call i32 @MPI_Recv(ptr %484, i32 %486, i32 1275069450, i32 %478, i32 0, i32 1140850688, ptr inttoptr (i64 1 to ptr))
+ br label %497
+
+488: ; preds = %456
+ br i1 %480, label %489, label %496
+
+489: ; preds = %488
+ %490 = extractvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } %475, 1
+ %491 = extractvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } %475, 2
+ %492 = getelementptr float, ptr %490, i64 %491
+ %493 = extractvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } %475, 3, 0
+ %494 = trunc i64 %493 to i32
+ %495 = call i32 @MPI_Send(ptr %492, i32 %494, i32 1275069450, i32 %476, i32 0, i32 1140850688)
+ br label %496
+
+496: ; preds = %489, %488
+ br label %497
+
+497: ; preds = %481, %496
+ %498 = extractvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } %62, 0
+ %499 = extractvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } %62, 1
+ %500 = insertvalue { ptr, ptr, i64 } poison, ptr %498, 0
+ %501 = insertvalue { ptr, ptr, i64 } %500, ptr %499, 1
+ %502 = insertvalue { ptr, ptr, i64 } %501, i64 0, 2
+ %503 = extractvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } %62, 2
+ %504 = extractvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } %62, 3, 0
+ %505 = extractvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } %62, 3, 1
+ %506 = extractvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } %62, 4, 0
+ %507 = extractvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } %62, 4, 1
+ %508 = extractvalue { ptr, ptr, i64 } %502, 0
+ %509 = extractvalue { ptr, ptr, i64 } %502, 1
+ %510 = insertvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } poison, ptr %508, 0
+ %511 = insertvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } %510, ptr %509, 1
+ %512 = insertvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } %511, i64 75000000, 2
+ %513 = insertvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } %512, i64 2500, 3, 0
+ %514 = insertvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } %513, i64 10000, 4, 0
+ %515 = insertvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } %514, i64 10000, 3, 1
+ %516 = insertvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } %515, i64 1, 4, 1
+ %517 = load i32, ptr %91, align 4
+ %518 = getelementptr inbounds nuw i32, ptr %91, i32 3
+ %519 = load i32, ptr %518, align 4
+ %520 = icmp eq i32 %66, %517
+ %521 = icmp eq i32 %66, %519
+ br i1 %520, label %522, label %529
+
+522: ; preds = %497
+ %523 = extractvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } %516, 1
+ %524 = extractvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } %516, 2
+ %525 = getelementptr float, ptr %523, i64 %524
+ %526 = extractvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } %516, 3, 0
+ %527 = trunc i64 %526 to i32
+ %528 = call i32 @MPI_Recv(ptr %525, i32 %527, i32 1275069450, i32 %519, i32 0, i32 1140850688, ptr inttoptr (i64 1 to ptr))
+ br label %538
+
+529: ; preds = %497
+ br i1 %521, label %530, label %537
+
+530: ; preds = %529
+ %531 = extractvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } %516, 1
+ %532 = extractvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } %516, 2
+ %533 = getelementptr float, ptr %531, i64 %532
+ %534 = extractvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } %516, 3, 0
+ %535 = trunc i64 %534 to i32
+ %536 = call i32 @MPI_Send(ptr %533, i32 %535, i32 1275069450, i32 %517, i32 0, i32 1140850688)
+ br label %537
+
+537: ; preds = %530, %529
+ br label %538
+
+538: ; preds = %522, %537
+ %539 = icmp eq i32 %98, 0
+ br i1 %539, label %540, label %541
+
+540: ; preds = %538
+ %omp_global_thread_num158 = call i32 @__kmpc_global_thread_num(ptr @1)
+ store { ptr, ptr, i64, [2 x i64], [2 x i64] } %288, ptr %.reloaded201, align 8
+ store float %5, ptr %.reloaded202, align 4
+ store { ptr, ptr, i64, [2 x i64], [2 x i64] } %269, ptr %.reloaded203, align 8
+ br label %omp_parallel357
+
+omp_parallel357: ; preds = %540
+ %gep_.reloaded201 = getelementptr { ptr, ptr, ptr, ptr }, ptr %structArg355, i32 0, i32 0
+ store ptr %.reloaded201, ptr %gep_.reloaded201, align 8
+ %gep_.reloaded202 = getelementptr { ptr, ptr, ptr, ptr }, ptr %structArg355, i32 0, i32 1
+ store ptr %.reloaded202, ptr %gep_.reloaded202, align 8
+ %gep_.reloaded203 = getelementptr { ptr, ptr, ptr, ptr }, ptr %structArg355, i32 0, i32 2
+ store ptr %.reloaded203, ptr %gep_.reloaded203, align 8
+ %gep_356 = getelementptr { ptr, ptr, ptr, ptr }, ptr %structArg355, i32 0, i32 3
+ store ptr %28, ptr %gep_356, align 8
+ call void (ptr, i32, ptr, ...) @__kmpc_fork_call(ptr @1, i32 1, ptr @kernel_2mm..omp_par.4, ptr %structArg355)
+ br label %omp.par.exit164
+
+omp.par.exit164: ; preds = %omp_parallel357
+ br label %541
+
+541: ; preds = %omp.par.exit164, %538
+ %542 = icmp eq i32 %98, 1
+ br i1 %542, label %543, label %544
+
+543: ; preds = %541
+ %omp_global_thread_num205 = call i32 @__kmpc_global_thread_num(ptr @1)
+ store { ptr, ptr, i64, [2 x i64], [2 x i64] } %326, ptr %.reloaded248, align 8
+ store float %5, ptr %.reloaded249, align 4
+ store { ptr, ptr, i64, [2 x i64], [2 x i64] } %307, ptr %.reloaded250, align 8
+ br label %omp_parallel360
+
+omp_parallel360: ; preds = %543
+ %gep_.reloaded248 = getelementptr { ptr, ptr, ptr, ptr }, ptr %structArg358, i32 0, i32 0
+ store ptr %.reloaded248, ptr %gep_.reloaded248, align 8
+ %gep_.reloaded249 = getelementptr { ptr, ptr, ptr, ptr }, ptr %structArg358, i32 0, i32 1
+ store ptr %.reloaded249, ptr %gep_.reloaded249, align 8
+ %gep_.reloaded250 = getelementptr { ptr, ptr, ptr, ptr }, ptr %structArg358, i32 0, i32 2
+ store ptr %.reloaded250, ptr %gep_.reloaded250, align 8
+ %gep_359 = getelementptr { ptr, ptr, ptr, ptr }, ptr %structArg358, i32 0, i32 3
+ store ptr %28, ptr %gep_359, align 8
+ call void (ptr, i32, ptr, ...) @__kmpc_fork_call(ptr @1, i32 1, ptr @kernel_2mm..omp_par.5, ptr %structArg358)
+ br label %omp.par.exit211
+
+omp.par.exit211: ; preds = %omp_parallel360
+ br label %544
+
+544: ; preds = %omp.par.exit211, %541
+ %545 = icmp eq i32 %98, 2
+ br i1 %545, label %546, label %547
+
+546: ; preds = %544
+ %omp_global_thread_num252 = call i32 @__kmpc_global_thread_num(ptr @1)
+ store { ptr, ptr, i64, [2 x i64], [2 x i64] } %364, ptr %.reloaded295, align 8
+ store float %5, ptr %.reloaded296, align 4
+ store { ptr, ptr, i64, [2 x i64], [2 x i64] } %345, ptr %.reloaded297, align 8
+ br label %omp_parallel363
+
+omp_parallel363: ; preds = %546
+ %gep_.reloaded295 = getelementptr { ptr, ptr, ptr, ptr }, ptr %structArg361, i32 0, i32 0
+ store ptr %.reloaded295, ptr %gep_.reloaded295, align 8
+ %gep_.reloaded296 = getelementptr { ptr, ptr, ptr, ptr }, ptr %structArg361, i32 0, i32 1
+ store ptr %.reloaded296, ptr %gep_.reloaded296, align 8
+ %gep_.reloaded297 = getelementptr { ptr, ptr, ptr, ptr }, ptr %structArg361, i32 0, i32 2
+ store ptr %.reloaded297, ptr %gep_.reloaded297, align 8
+ %gep_362 = getelementptr { ptr, ptr, ptr, ptr }, ptr %structArg361, i32 0, i32 3
+ store ptr %28, ptr %gep_362, align 8
+ call void (ptr, i32, ptr, ...) @__kmpc_fork_call(ptr @1, i32 1, ptr @kernel_2mm..omp_par.6, ptr %structArg361)
+ br label %omp.par.exit258
+
+omp.par.exit258: ; preds = %omp_parallel363
+ br label %547
+
+547: ; preds = %omp.par.exit258, %544
+ %548 = icmp eq i32 %98, 3
+ br i1 %548, label %549, label %550
+
+549: ; preds = %547
+ %omp_global_thread_num299 = call i32 @__kmpc_global_thread_num(ptr @1)
+ store { ptr, ptr, i64, [2 x i64], [2 x i64] } %402, ptr %.reloaded342, align 8
+ store float %5, ptr %.reloaded343, align 4
+ store { ptr, ptr, i64, [2 x i64], [2 x i64] } %383, ptr %.reloaded344, align 8
+ br label %omp_parallel366
+
+omp_parallel366: ; preds = %549
+ %gep_.reloaded342 = getelementptr { ptr, ptr, ptr, ptr }, ptr %structArg364, i32 0, i32 0
+ store ptr %.reloaded342, ptr %gep_.reloaded342, align 8
+ %gep_.reloaded343 = getelementptr { ptr, ptr, ptr, ptr }, ptr %structArg364, i32 0, i32 1
+ store ptr %.reloaded343, ptr %gep_.reloaded343, align 8
+ %gep_.reloaded344 = getelementptr { ptr, ptr, ptr, ptr }, ptr %structArg364, i32 0, i32 2
+ store ptr %.reloaded344, ptr %gep_.reloaded344, align 8
+ %gep_365 = getelementptr { ptr, ptr, ptr, ptr }, ptr %structArg364, i32 0, i32 3
+ store ptr %28, ptr %gep_365, align 8
+ call void (ptr, i32, ptr, ...) @__kmpc_fork_call(ptr @1, i32 1, ptr @kernel_2mm..omp_par.7, ptr %structArg364)
+ br label %omp.par.exit305
+
+omp.par.exit305: ; preds = %omp_parallel366
+ br label %550
+
+550: ; preds = %omp.par.exit305, %547
+ %551 = call i32 @MPI_Barrier(i32 1140850688)
+ %552 = extractvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } %48, 0
+ %553 = extractvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } %48, 1
+ %554 = insertvalue { ptr, ptr, i64 } poison, ptr %552, 0
+ %555 = insertvalue { ptr, ptr, i64 } %554, ptr %553, 1
+ %556 = insertvalue { ptr, ptr, i64 } %555, i64 0, 2
+ %557 = extractvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } %48, 2
+ %558 = extractvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } %48, 3, 0
+ %559 = extractvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } %48, 3, 1
+ %560 = extractvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } %48, 4, 0
+ %561 = extractvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } %48, 4, 1
+ %562 = extractvalue { ptr, ptr, i64 } %556, 0
+ %563 = extractvalue { ptr, ptr, i64 } %556, 1
+ %564 = insertvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } poison, ptr %562, 0
+ %565 = insertvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } %564, ptr %563, 1
+ %566 = insertvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } %565, i64 25000000, 2
+ %567 = insertvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } %566, i64 2500, 3, 0
+ %568 = insertvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } %567, i64 10000, 4, 0
+ %569 = insertvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } %568, i64 10000, 3, 1
+ %570 = insertvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } %569, i64 1, 4, 1
+ %571 = load i32, ptr %91, align 4
+ %572 = getelementptr inbounds nuw i32, ptr %91, i32 1
+ %573 = load i32, ptr %572, align 4
+ %574 = icmp eq i32 %66, %571
+ %575 = icmp eq i32 %66, %573
+ br i1 %574, label %576, label %583
+
+576: ; preds = %550
+ %577 = extractvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } %570, 1
+ %578 = extractvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } %570, 2
+ %579 = getelementptr float, ptr %577, i64 %578
+ %580 = extractvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } %570, 3, 0
+ %581 = trunc i64 %580 to i32
+ %582 = call i32 @MPI_Recv(ptr %579, i32 %581, i32 1275069450, i32 %573, i32 0, i32 1140850688, ptr inttoptr (i64 1 to ptr))
+ br label %592
+
+583: ; preds = %550
+ br i1 %575, label %584, label %591
+
+584: ; preds = %583
+ %585 = extractvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } %570, 1
+ %586 = extractvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } %570, 2
+ %587 = getelementptr float, ptr %585, i64 %586
+ %588 = extractvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } %570, 3, 0
+ %589 = trunc i64 %588 to i32
+ %590 = call i32 @MPI_Send(ptr %587, i32 %589, i32 1275069450, i32 %571, i32 0, i32 1140850688)
+ br label %591
+
+591: ; preds = %584, %583
+ br label %592
+
+592: ; preds = %576, %591
+ %593 = extractvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } %48, 0
+ %594 = extractvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } %48, 1
+ %595 = insertvalue { ptr, ptr, i64 } poison, ptr %593, 0
+ %596 = insertvalue { ptr, ptr, i64 } %595, ptr %594, 1
+ %597 = insertvalue { ptr, ptr, i64 } %596, i64 0, 2
+ %598 = extractvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } %48, 2
+ %599 = extractvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } %48, 3, 0
+ %600 = extractvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } %48, 3, 1
+ %601 = extractvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } %48, 4, 0
+ %602 = extractvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } %48, 4, 1
+ %603 = extractvalue { ptr, ptr, i64 } %597, 0
+ %604 = extractvalue { ptr, ptr, i64 } %597, 1
+ %605 = insertvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } poison, ptr %603, 0
+ %606 = insertvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } %605, ptr %604, 1
+ %607 = insertvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } %606, i64 50000000, 2
+ %608 = insertvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } %607, i64 2500, 3, 0
+ %609 = insertvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } %608, i64 10000, 4, 0
+ %610 = insertvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } %609, i64 10000, 3, 1
+ %611 = insertvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } %610, i64 1, 4, 1
+ %612 = load i32, ptr %91, align 4
+ %613 = getelementptr inbounds nuw i32, ptr %91, i32 2
+ %614 = load i32, ptr %613, align 4
+ %615 = icmp eq i32 %66, %612
+ %616 = icmp eq i32 %66, %614
+ br i1 %615, label %617, label %624
+
+617: ; preds = %592
+ %618 = extractvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } %611, 1
+ %619 = extractvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } %611, 2
+ %620 = getelementptr float, ptr %618, i64 %619
+ %621 = extractvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } %611, 3, 0
+ %622 = trunc i64 %621 to i32
+ %623 = call i32 @MPI_Recv(ptr %620, i32 %622, i32 1275069450, i32 %614, i32 0, i32 1140850688, ptr inttoptr (i64 1 to ptr))
+ br label %633
+
+624: ; preds = %592
+ br i1 %616, label %625, label %632
+
+625: ; preds = %624
+ %626 = extractvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } %611, 1
+ %627 = extractvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } %611, 2
+ %628 = getelementptr float, ptr %626, i64 %627
+ %629 = extractvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } %611, 3, 0
+ %630 = trunc i64 %629 to i32
+ %631 = call i32 @MPI_Send(ptr %628, i32 %630, i32 1275069450, i32 %612, i32 0, i32 1140850688)
+ br label %632
+
+632: ; preds = %625, %624
+ br label %633
+
+633: ; preds = %617, %632
+ %634 = extractvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } %48, 0
+ %635 = extractvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } %48, 1
+ %636 = insertvalue { ptr, ptr, i64 } poison, ptr %634, 0
+ %637 = insertvalue { ptr, ptr, i64 } %636, ptr %635, 1
+ %638 = insertvalue { ptr, ptr, i64 } %637, i64 0, 2
+ %639 = extractvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } %48, 2
+ %640 = extractvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } %48, 3, 0
+ %641 = extractvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } %48, 3, 1
+ %642 = extractvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } %48, 4, 0
+ %643 = extractvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } %48, 4, 1
+ %644 = extractvalue { ptr, ptr, i64 } %638, 0
+ %645 = extractvalue { ptr, ptr, i64 } %638, 1
+ %646 = insertvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } poison, ptr %644, 0
+ %647 = insertvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } %646, ptr %645, 1
+ %648 = insertvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } %647, i64 75000000, 2
+ %649 = insertvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } %648, i64 2500, 3, 0
+ %650 = insertvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } %649, i64 10000, 4, 0
+ %651 = insertvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } %650, i64 10000, 3, 1
+ %652 = insertvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } %651, i64 1, 4, 1
+ %653 = load i32, ptr %91, align 4
+ %654 = getelementptr inbounds nuw i32, ptr %91, i32 3
+ %655 = load i32, ptr %654, align 4
+ %656 = icmp eq i32 %66, %653
+ %657 = icmp eq i32 %66, %655
+ br i1 %656, label %658, label %665
+
+658: ; preds = %633
+ %659 = extractvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } %652, 1
+ %660 = extractvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } %652, 2
+ %661 = getelementptr float, ptr %659, i64 %660
+ %662 = extractvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } %652, 3, 0
+ %663 = trunc i64 %662 to i32
+ %664 = call i32 @MPI_Recv(ptr %661, i32 %663, i32 1275069450, i32 %655, i32 0, i32 1140850688, ptr inttoptr (i64 1 to ptr))
+ br label %674
+
+665: ; preds = %633
+ br i1 %657, label %666, label %673
+
+666: ; preds = %665
+ %667 = extractvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } %652, 1
+ %668 = extractvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } %652, 2
+ %669 = getelementptr float, ptr %667, i64 %668
+ %670 = extractvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } %652, 3, 0
+ %671 = trunc i64 %670 to i32
+ %672 = call i32 @MPI_Send(ptr %669, i32 %671, i32 1275069450, i32 %653, i32 0, i32 1140850688)
+ br label %673
+
+673: ; preds = %666, %665
+ br label %674
+
+674: ; preds = %658, %673
+ %675 = call i32 @MPI_Barrier(i32 1140850688)
ret void
}
; Function Attrs: nounwind
-define internal void @testFunc..omp_par.3(ptr noalias %tid.addr104, ptr noalias %zero.addr105, ptr %0) #0 {
-omp.par.entry106:
- %gep_.reloaded143 = getelementptr { ptr, ptr, ptr, ptr }, ptr %0, i32 0, i32 0
- %loadgep_.reloaded143 = load ptr, ptr %gep_.reloaded143, align 8
- %gep_.reloaded144 = getelementptr { ptr, ptr, ptr, ptr }, ptr %0, i32 0, i32 1
- %loadgep_.reloaded144 = load ptr, ptr %gep_.reloaded144, align 8
- %gep_.reloaded145 = getelementptr { ptr, ptr, ptr, ptr }, ptr %0, i32 0, i32 2
- %loadgep_.reloaded145 = load ptr, ptr %gep_.reloaded145, align 8
- %gep_.reloaded146 = getelementptr { ptr, ptr, ptr, ptr }, ptr %0, i32 0, i32 3
- %loadgep_.reloaded146 = load ptr, ptr %gep_.reloaded146, align 8
- %p.lastiter135 = alloca i32, align 4
- %p.lowerbound136 = alloca i64, align 8
- %p.upperbound137 = alloca i64, align 8
- %p.stride138 = alloca i64, align 8
- %tid.addr.local109 = alloca i32, align 4
- %1 = load i32, ptr %tid.addr104, align 4
- store i32 %1, ptr %tid.addr.local109, align 4
- %tid110 = load i32, ptr %tid.addr.local109, align 4
- %2 = load { ptr, ptr, i64, [2 x i64], [2 x i64] }, ptr %loadgep_.reloaded143, align 8
- %3 = load float, ptr %loadgep_.reloaded144, align 4
- %4 = load { ptr, ptr, i64, [2 x i64], [2 x i64] }, ptr %loadgep_.reloaded145, align 8
- %5 = load { ptr, ptr, i64, [2 x i64], [2 x i64] }, ptr %loadgep_.reloaded146, align 8
- br label %omp.region.after_alloca116
-
-omp.region.after_alloca116: ; preds = %omp.par.entry106
- br label %omp.region.after_alloca113
-
-omp.region.after_alloca113: ; preds = %omp.region.after_alloca116
- br label %omp.par.region107
-
-omp.par.region107: ; preds = %omp.region.after_alloca113
- br label %omp.par.region115
-
-omp.par.region115: ; preds = %omp.par.region107
- br label %omp_loop.preheader117
-
-omp_loop.preheader117: ; preds = %omp.par.region115
- store i64 0, ptr %p.lowerbound136, align 4
- store i64 499, ptr %p.upperbound137, align 4
- store i64 1, ptr %p.stride138, align 4
- %omp_global_thread_num139 = call i32 @__kmpc_global_thread_num(ptr @1)
- call void @__kmpc_for_static_init_8u(ptr @1, i32 %omp_global_thread_num139, i32 34, ptr %p.lastiter135, ptr %p.lowerbound136, ptr %p.upperbound137, ptr %p.stride138, i64 1, i64 0)
- %6 = load i64, ptr %p.lowerbound136, align 4
- %7 = load i64, ptr %p.upperbound137, align 4
- %8 = sub i64 %7, %6
- %9 = add i64 %8, 1
- br label %omp_loop.header118
-
-omp_loop.header118: ; preds = %omp_loop.inc121, %omp_loop.preheader117
- %omp_loop.iv124 = phi i64 [ 0, %omp_loop.preheader117 ], [ %omp_loop.next126, %omp_loop.inc121 ]
- br label %omp_loop.cond119
-
-omp_loop.cond119: ; preds = %omp_loop.header118
- %omp_loop.cmp125 = icmp ult i64 %omp_loop.iv124, %9
- br i1 %omp_loop.cmp125, label %omp_loop.body120, label %omp_loop.exit122
-
-omp_loop.exit122: ; preds = %omp_loop.cond119
- call void @__kmpc_for_static_fini(ptr @1, i32 %omp_global_thread_num139)
- %omp_global_thread_num140 = call i32 @__kmpc_global_thread_num(ptr @1)
- call void @__kmpc_barrier(ptr @2, i32 %omp_global_thread_num140)
- br label %omp_loop.after123
-
-omp_loop.after123: ; preds = %omp_loop.exit122
- br label %omp.region.cont114
-
-omp.region.cont114: ; preds = %omp_loop.after123
- br label %omp.par.pre_finalize108
-
-omp.par.pre_finalize108: ; preds = %omp.region.cont114
- br label %omp.par.outlined.exit142.exitStub
-
-omp_loop.body120: ; preds = %omp_loop.cond119
- %10 = add i64 %omp_loop.iv124, %6
- %11 = mul i64 %10, 1
- %12 = add i64 %11, 0
- br label %omp.wsloop.region128
-
-omp.wsloop.region128: ; preds = %omp_loop.body120
- br label %omp.wsloop.region129
-
-omp.wsloop.region129: ; preds = %omp.wsloop.region133, %omp.wsloop.region128
- %13 = phi i64 [ %25, %omp.wsloop.region133 ], [ 0, %omp.wsloop.region128 ]
- %14 = icmp slt i64 %13, 1000
- br i1 %14, label %omp.wsloop.region130, label %omp.wsloop.region134
-
-omp.wsloop.region134: ; preds = %omp.wsloop.region129
- br label %omp.region.cont127
-
-omp.region.cont127: ; preds = %omp.wsloop.region134
- br label %omp_loop.inc121
-
-omp_loop.inc121: ; preds = %omp.region.cont127
- %omp_loop.next126 = add nuw i64 %omp_loop.iv124, 1
- br label %omp_loop.header118
-
-omp.wsloop.region130: ; preds = %omp.wsloop.region129
+define internal void @kernel_2mm..omp_par.7(ptr noalias %tid.addr300, ptr noalias %zero.addr301, ptr %0) #0 {
+omp.par.entry302:
+ %gep_.reloaded342 = getelementptr { ptr, ptr, ptr, ptr }, ptr %0, i32 0, i32 0
+ %loadgep_.reloaded342 = load ptr, ptr %gep_.reloaded342, align 8, !align !1
+ %gep_.reloaded343 = getelementptr { ptr, ptr, ptr, ptr }, ptr %0, i32 0, i32 1
+ %loadgep_.reloaded343 = load ptr, ptr %gep_.reloaded343, align 8, !align !2
+ %gep_.reloaded344 = getelementptr { ptr, ptr, ptr, ptr }, ptr %0, i32 0, i32 2
+ %loadgep_.reloaded344 = load ptr, ptr %gep_.reloaded344, align 8, !align !1
+ %gep_ = getelementptr { ptr, ptr, ptr, ptr }, ptr %0, i32 0, i32 3
+ %loadgep_ = load ptr, ptr %gep_, align 8, !align !3
+ %p.lastiter336 = alloca i32, align 4
+ %p.lowerbound337 = alloca i64, align 8
+ %p.upperbound338 = alloca i64, align 8
+ %p.stride339 = alloca i64, align 8
+ %tid.addr.local306 = alloca i32, align 4
+ %1 = load i32, ptr %tid.addr300, align 4
+ store i32 %1, ptr %tid.addr.local306, align 4
+ %tid307 = load i32, ptr %tid.addr.local306, align 4
+ %2 = load { ptr, ptr, i64, [2 x i64], [2 x i64] }, ptr %loadgep_.reloaded342, align 8
+ %3 = load float, ptr %loadgep_.reloaded343, align 4
+ %4 = load { ptr, ptr, i64, [2 x i64], [2 x i64] }, ptr %loadgep_.reloaded344, align 8
+ br label %omp.region.after_alloca313
+
+omp.region.after_alloca313: ; preds = %omp.par.entry302
+ br label %omp.region.after_alloca310
+
+omp.region.after_alloca310: ; preds = %omp.region.after_alloca313
+ br label %omp.par.region303
+
+omp.par.region303: ; preds = %omp.region.after_alloca310
+ br label %omp.par.region312
+
+omp.par.region312: ; preds = %omp.par.region303
+ br label %omp.wsloop.region315
+
+omp.wsloop.region315: ; preds = %omp.par.region312
+ br label %omp_loop.preheader316
+
+omp_loop.preheader316: ; preds = %omp.wsloop.region315
+ store i64 0, ptr %p.lowerbound337, align 4
+ store i64 2499, ptr %p.upperbound338, align 4
+ store i64 1, ptr %p.stride339, align 4
+ %omp_global_thread_num340 = call i32 @__kmpc_global_thread_num(ptr @1)
+ call void @__kmpc_for_static_init_8u(ptr @1, i32 %omp_global_thread_num340, i32 34, ptr %p.lastiter336, ptr %p.lowerbound337, ptr %p.upperbound338, ptr %p.stride339, i64 1, i64 0)
+ %5 = load i64, ptr %p.lowerbound337, align 4
+ %6 = load i64, ptr %p.upperbound338, align 4
+ %7 = sub i64 %6, %5
+ %8 = add i64 %7, 1
+ br label %omp_loop.header317
+
+omp_loop.header317: ; preds = %omp_loop.inc320, %omp_loop.preheader316
+ %omp_loop.iv323 = phi i64 [ 0, %omp_loop.preheader316 ], [ %omp_loop.next325, %omp_loop.inc320 ]
+ br label %omp_loop.cond318
+
+omp_loop.cond318: ; preds = %omp_loop.header317
+ %omp_loop.cmp324 = icmp ult i64 %omp_loop.iv323, %8
+ br i1 %omp_loop.cmp324, label %omp_loop.body319, label %omp_loop.exit321
+
+omp_loop.exit321: ; preds = %omp_loop.cond318
+ call void @__kmpc_for_static_fini(ptr @1, i32 %omp_global_thread_num340)
+ %omp_global_thread_num341 = call i32 @__kmpc_global_thread_num(ptr @1)
+ call void @__kmpc_barrier(ptr @2, i32 %omp_global_thread_num341)
+ br label %omp_loop.after322
+
+omp_loop.after322: ; preds = %omp_loop.exit321
+ br label %omp.region.cont314
+
+omp.region.cont314: ; preds = %omp_loop.after322
+ br label %omp.region.cont311
+
+omp.region.cont311: ; preds = %omp.region.cont314
+ br label %omp.par.pre_finalize304
+
+omp.par.pre_finalize304: ; preds = %omp.region.cont311
+ br label %.fini345
+
+.fini345: ; preds = %omp.par.pre_finalize304
+ br label %omp.par.exit305.exitStub
+
+omp_loop.body319: ; preds = %omp_loop.cond318
+ %9 = add i64 %omp_loop.iv323, %5
+ %10 = mul i64 %9, 1
+ %11 = add i64 %10, 0
+ br label %omp.loop_nest.region327
+
+omp.loop_nest.region327: ; preds = %omp_loop.body319
+ %12 = call ptr @llvm.stacksave.p0()
+ br label %omp.loop_nest.region328
+
+omp.loop_nest.region328: ; preds = %omp.loop_nest.region327
+ br label %omp.loop_nest.region329
+
+omp.loop_nest.region329: ; preds = %omp.loop_nest.region333, %omp.loop_nest.region328
+ %13 = phi i64 [ %29, %omp.loop_nest.region333 ], [ 0, %omp.loop_nest.region328 ]
+ %14 = icmp slt i64 %13, 10000
+ br i1 %14, label %omp.loop_nest.region330, label %omp.loop_nest.region334
+
+omp.loop_nest.region334: ; preds = %omp.loop_nest.region329
+ call void @llvm.stackrestore.p0(ptr %12)
+ br label %omp.loop_nest.region335
+
+omp.loop_nest.region335: ; preds = %omp.loop_nest.region334
+ br label %omp.region.cont326
+
+omp.region.cont326: ; preds = %omp.loop_nest.region335
+ br label %omp_loop.inc320
+
+omp_loop.inc320: ; preds = %omp.region.cont326
+ %omp_loop.next325 = add nuw i64 %omp_loop.iv323, 1
+ br label %omp_loop.header317
+
+omp.loop_nest.region330: ; preds = %omp.loop_nest.region329
%15 = extractvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } %2, 1
- %16 = add nuw nsw i64 0, %13
- %17 = getelementptr float, ptr %15, i64 %16
- %18 = load float, ptr %17, align 4
- %19 = fmul float %18, %3
- %20 = extractvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } %2, 1
- %21 = add nuw nsw i64 0, %13
- %22 = getelementptr float, ptr %20, i64 %21
- store float %19, ptr %22, align 4
- br label %omp.wsloop.region131
-
-omp.wsloop.region131: ; preds = %omp.wsloop.region132, %omp.wsloop.region130
- %23 = phi i64 [ %44, %omp.wsloop.region132 ], [ 0, %omp.wsloop.region130 ]
- %24 = icmp slt i64 %23, 1000
- br i1 %24, label %omp.wsloop.region132, label %omp.wsloop.region133
-
-omp.wsloop.region133: ; preds = %omp.wsloop.region131
- %25 = add i64 %13, 1
- br label %omp.wsloop.region129
-
-omp.wsloop.region132: ; preds = %omp.wsloop.region131
- %26 = extractvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } %4, 1
- %27 = add nuw nsw i64 0, %23
- %28 = getelementptr float, ptr %26, i64 %27
- %29 = load float, ptr %28, align 4
- %30 = extractvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } %5, 1
- %31 = mul nuw nsw i64 %23, 1000
- %32 = add nuw nsw i64 %31, %13
- %33 = getelementptr float, ptr %30, i64 %32
- %34 = load float, ptr %33, align 4
- %35 = fmul float %29, %34
- %36 = extractvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } %2, 1
- %37 = add nuw nsw i64 0, %13
- %38 = getelementptr float, ptr %36, i64 %37
+ %16 = getelementptr float, ptr %15, i32 75000000
+ %17 = mul nuw nsw i64 %11, 10000
+ %18 = add nuw nsw i64 %17, %13
+ %19 = getelementptr inbounds nuw float, ptr %16, i64 %18
+ %20 = load float, ptr %19, align 4
+ %21 = fmul float %20, %3
+ %22 = extractvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } %2, 1
+ %23 = getelementptr float, ptr %22, i32 75000000
+ %24 = mul nuw nsw i64 %11, 10000
+ %25 = add nuw nsw i64 %24, %13
+ %26 = getelementptr inbounds nuw float, ptr %23, i64 %25
+ store float %21, ptr %26, align 4
+ br label %omp.loop_nest.region331
+
+omp.loop_nest.region331: ; preds = %omp.loop_nest.region332, %omp.loop_nest.region330
+ %27 = phi i64 [ %53, %omp.loop_nest.region332 ], [ 0, %omp.loop_nest.region330 ]
+ %28 = icmp slt i64 %27, 10000
+ br i1 %28, label %omp.loop_nest.region332, label %omp.loop_nest.region333
+
+omp.loop_nest.region333: ; preds = %omp.loop_nest.region331
+ %29 = add i64 %13, 1
+ br label %omp.loop_nest.region329
+
+omp.loop_nest.region332: ; preds = %omp.loop_nest.region331
+ %30 = extractvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } %4, 1
+ %31 = getelementptr float, ptr %30, i32 75000000
+ %32 = mul nuw nsw i64 %11, 10000
+ %33 = add nuw nsw i64 %32, %27
+ %34 = getelementptr inbounds nuw float, ptr %31, i64 %33
+ %35 = load float, ptr %34, align 4
+ %36 = mul nuw nsw i64 %27, 10000
+ %37 = add nuw nsw i64 %36, %13
+ %38 = getelementptr inbounds nuw float, ptr %loadgep_, i64 %37
%39 = load float, ptr %38, align 4
- %40 = fadd float %39, %35
+ %40 = fmul float %35, %39
%41 = extractvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } %2, 1
- %42 = add nuw nsw i64 0, %13
- %43 = getelementptr float, ptr %41, i64 %42
- store float %40, ptr %43, align 4
- %44 = add i64 %23, 1
- br label %omp.wsloop.region131
+ %42 = getelementptr float, ptr %41, i32 75000000
+ %43 = mul nuw nsw i64 %11, 10000
+ %44 = add nuw nsw i64 %43, %13
+ %45 = getelementptr inbounds nuw float, ptr %42, i64 %44
+ %46 = load float, ptr %45, align 4
+ %47 = fadd float %46, %40
+ %48 = extractvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } %2, 1
+ %49 = getelementptr float, ptr %48, i32 75000000
+ %50 = mul nuw nsw i64 %11, 10000
+ %51 = add nuw nsw i64 %50, %13
+ %52 = getelementptr inbounds nuw float, ptr %49, i64 %51
+ store float %47, ptr %52, align 4
+ %53 = add i64 %27, 1
+ br label %omp.loop_nest.region331
+
+omp.par.exit305.exitStub: ; preds = %.fini345
+ ret void
+}
-omp.par.outlined.exit142.exitStub: ; preds = %omp.par.pre_finalize108
+; Function Attrs: nounwind
+define internal void @kernel_2mm..omp_par.6(ptr noalias %tid.addr253, ptr noalias %zero.addr254, ptr %0) #0 {
+omp.par.entry255:
+ %gep_.reloaded295 = getelementptr { ptr, ptr, ptr, ptr }, ptr %0, i32 0, i32 0
+ %loadgep_.reloaded295 = load ptr, ptr %gep_.reloaded295, align 8, !align !1
+ %gep_.reloaded296 = getelementptr { ptr, ptr, ptr, ptr }, ptr %0, i32 0, i32 1
+ %loadgep_.reloaded296 = load ptr, ptr %gep_.reloaded296, align 8, !align !2
+ %gep_.reloaded297 = getelementptr { ptr, ptr, ptr, ptr }, ptr %0, i32 0, i32 2
+ %loadgep_.reloaded297 = load ptr, ptr %gep_.reloaded297, align 8, !align !1
+ %gep_ = getelementptr { ptr, ptr, ptr, ptr }, ptr %0, i32 0, i32 3
+ %loadgep_ = load ptr, ptr %gep_, align 8, !align !3
+ %p.lastiter289 = alloca i32, align 4
+ %p.lowerbound290 = alloca i64, align 8
+ %p.upperbound291 = alloca i64, align 8
+ %p.stride292 = alloca i64, align 8
+ %tid.addr.local259 = alloca i32, align 4
+ %1 = load i32, ptr %tid.addr253, align 4
+ store i32 %1, ptr %tid.addr.local259, align 4
+ %tid260 = load i32, ptr %tid.addr.local259, align 4
+ %2 = load { ptr, ptr, i64, [2 x i64], [2 x i64] }, ptr %loadgep_.reloaded295, align 8
+ %3 = load float, ptr %loadgep_.reloaded296, align 4
+ %4 = load { ptr, ptr, i64, [2 x i64], [2 x i64] }, ptr %loadgep_.reloaded297, align 8
+ br label %omp.region.after_alloca266
+
+omp.region.after_alloca266: ; preds = %omp.par.entry255
+ br label %omp.region.after_alloca263
+
+omp.region.after_alloca263: ; preds = %omp.region.after_alloca266
+ br label %omp.par.region256
+
+omp.par.region256: ; preds = %omp.region.after_alloca263
+ br label %omp.par.region265
+
+omp.par.region265: ; preds = %omp.par.region256
+ br label %omp.wsloop.region268
+
+omp.wsloop.region268: ; preds = %omp.par.region265
+ br label %omp_loop.preheader269
+
+omp_loop.preheader269: ; preds = %omp.wsloop.region268
+ store i64 0, ptr %p.lowerbound290, align 4
+ store i64 2499, ptr %p.upperbound291, align 4
+ store i64 1, ptr %p.stride292, align 4
+ %omp_global_thread_num293 = call i32 @__kmpc_global_thread_num(ptr @1)
+ call void @__kmpc_for_static_init_8u(ptr @1, i32 %omp_global_thread_num293, i32 34, ptr %p.lastiter289, ptr %p.lowerbound290, ptr %p.upperbound291, ptr %p.stride292, i64 1, i64 0)
+ %5 = load i64, ptr %p.lowerbound290, align 4
+ %6 = load i64, ptr %p.upperbound291, align 4
+ %7 = sub i64 %6, %5
+ %8 = add i64 %7, 1
+ br label %omp_loop.header270
+
+omp_loop.header270: ; preds = %omp_loop.inc273, %omp_loop.preheader269
+ %omp_loop.iv276 = phi i64 [ 0, %omp_loop.preheader269 ], [ %omp_loop.next278, %omp_loop.inc273 ]
+ br label %omp_loop.cond271
+
+omp_loop.cond271: ; preds = %omp_loop.header270
+ %omp_loop.cmp277 = icmp ult i64 %omp_loop.iv276, %8
+ br i1 %omp_loop.cmp277, label %omp_loop.body272, label %omp_loop.exit274
+
+omp_loop.exit274: ; preds = %omp_loop.cond271
+ call void @__kmpc_for_static_fini(ptr @1, i32 %omp_global_thread_num293)
+ %omp_global_thread_num294 = call i32 @__kmpc_global_thread_num(ptr @1)
+ call void @__kmpc_barrier(ptr @2, i32 %omp_global_thread_num294)
+ br label %omp_loop.after275
+
+omp_loop.after275: ; preds = %omp_loop.exit274
+ br label %omp.region.cont267
+
+omp.region.cont267: ; preds = %omp_loop.after275
+ br label %omp.region.cont264
+
+omp.region.cont264: ; preds = %omp.region.cont267
+ br label %omp.par.pre_finalize257
+
+omp.par.pre_finalize257: ; preds = %omp.region.cont264
+ br label %.fini298
+
+.fini298: ; preds = %omp.par.pre_finalize257
+ br label %omp.par.exit258.exitStub
+
+omp_loop.body272: ; preds = %omp_loop.cond271
+ %9 = add i64 %omp_loop.iv276, %5
+ %10 = mul i64 %9, 1
+ %11 = add i64 %10, 0
+ br label %omp.loop_nest.region280
+
+omp.loop_nest.region280: ; preds = %omp_loop.body272
+ %12 = call ptr @llvm.stacksave.p0()
+ br label %omp.loop_nest.region281
+
+omp.loop_nest.region281: ; preds = %omp.loop_nest.region280
+ br label %omp.loop_nest.region282
+
+omp.loop_nest.region282: ; preds = %omp.loop_nest.region286, %omp.loop_nest.region281
+ %13 = phi i64 [ %29, %omp.loop_nest.region286 ], [ 0, %omp.loop_nest.region281 ]
+ %14 = icmp slt i64 %13, 10000
+ br i1 %14, label %omp.loop_nest.region283, label %omp.loop_nest.region287
+
+omp.loop_nest.region287: ; preds = %omp.loop_nest.region282
+ call void @llvm.stackrestore.p0(ptr %12)
+ br label %omp.loop_nest.region288
+
+omp.loop_nest.region288: ; preds = %omp.loop_nest.region287
+ br label %omp.region.cont279
+
+omp.region.cont279: ; preds = %omp.loop_nest.region288
+ br label %omp_loop.inc273
+
+omp_loop.inc273: ; preds = %omp.region.cont279
+ %omp_loop.next278 = add nuw i64 %omp_loop.iv276, 1
+ br label %omp_loop.header270
+
+omp.loop_nest.region283: ; preds = %omp.loop_nest.region282
+ %15 = extractvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } %2, 1
+ %16 = getelementptr float, ptr %15, i32 50000000
+ %17 = mul nuw nsw i64 %11, 10000
+ %18 = add nuw nsw i64 %17, %13
+ %19 = getelementptr inbounds nuw float, ptr %16, i64 %18
+ %20 = load float, ptr %19, align 4
+ %21 = fmul float %20, %3
+ %22 = extractvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } %2, 1
+ %23 = getelementptr float, ptr %22, i32 50000000
+ %24 = mul nuw nsw i64 %11, 10000
+ %25 = add nuw nsw i64 %24, %13
+ %26 = getelementptr inbounds nuw float, ptr %23, i64 %25
+ store float %21, ptr %26, align 4
+ br label %omp.loop_nest.region284
+
+omp.loop_nest.region284: ; preds = %omp.loop_nest.region285, %omp.loop_nest.region283
+ %27 = phi i64 [ %53, %omp.loop_nest.region285 ], [ 0, %omp.loop_nest.region283 ]
+ %28 = icmp slt i64 %27, 10000
+ br i1 %28, label %omp.loop_nest.region285, label %omp.loop_nest.region286
+
+omp.loop_nest.region286: ; preds = %omp.loop_nest.region284
+ %29 = add i64 %13, 1
+ br label %omp.loop_nest.region282
+
+omp.loop_nest.region285: ; preds = %omp.loop_nest.region284
+ %30 = extractvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } %4, 1
+ %31 = getelementptr float, ptr %30, i32 50000000
+ %32 = mul nuw nsw i64 %11, 10000
+ %33 = add nuw nsw i64 %32, %27
+ %34 = getelementptr inbounds nuw float, ptr %31, i64 %33
+ %35 = load float, ptr %34, align 4
+ %36 = mul nuw nsw i64 %27, 10000
+ %37 = add nuw nsw i64 %36, %13
+ %38 = getelementptr inbounds nuw float, ptr %loadgep_, i64 %37
+ %39 = load float, ptr %38, align 4
+ %40 = fmul float %35, %39
+ %41 = extractvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } %2, 1
+ %42 = getelementptr float, ptr %41, i32 50000000
+ %43 = mul nuw nsw i64 %11, 10000
+ %44 = add nuw nsw i64 %43, %13
+ %45 = getelementptr inbounds nuw float, ptr %42, i64 %44
+ %46 = load float, ptr %45, align 4
+ %47 = fadd float %46, %40
+ %48 = extractvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } %2, 1
+ %49 = getelementptr float, ptr %48, i32 50000000
+ %50 = mul nuw nsw i64 %11, 10000
+ %51 = add nuw nsw i64 %50, %13
+ %52 = getelementptr inbounds nuw float, ptr %49, i64 %51
+ store float %47, ptr %52, align 4
+ %53 = add i64 %27, 1
+ br label %omp.loop_nest.region284
+
+omp.par.exit258.exitStub: ; preds = %.fini298
ret void
}
; Function Attrs: nounwind
-define internal void @testFunc..omp_par.2(ptr noalias %tid.addr60, ptr noalias %zero.addr61, ptr %0) #0 {
-omp.par.entry62:
- %gep_.reloaded99 = getelementptr { ptr, ptr, ptr, ptr }, ptr %0, i32 0, i32 0
- %loadgep_.reloaded99 = load ptr, ptr %gep_.reloaded99, align 8
- %gep_.reloaded100 = getelementptr { ptr, ptr, ptr, ptr }, ptr %0, i32 0, i32 1
- %loadgep_.reloaded100 = load ptr, ptr %gep_.reloaded100, align 8
- %gep_.reloaded101 = getelementptr { ptr, ptr, ptr, ptr }, ptr %0, i32 0, i32 2
- %loadgep_.reloaded101 = load ptr, ptr %gep_.reloaded101, align 8
- %gep_.reloaded102 = getelementptr { ptr, ptr, ptr, ptr }, ptr %0, i32 0, i32 3
- %loadgep_.reloaded102 = load ptr, ptr %gep_.reloaded102, align 8
- %p.lastiter91 = alloca i32, align 4
- %p.lowerbound92 = alloca i64, align 8
- %p.upperbound93 = alloca i64, align 8
- %p.stride94 = alloca i64, align 8
- %tid.addr.local65 = alloca i32, align 4
- %1 = load i32, ptr %tid.addr60, align 4
- store i32 %1, ptr %tid.addr.local65, align 4
- %tid66 = load i32, ptr %tid.addr.local65, align 4
- %2 = load { ptr, ptr, i64, [2 x i64], [2 x i64] }, ptr %loadgep_.reloaded99, align 8
- %3 = load float, ptr %loadgep_.reloaded100, align 4
- %4 = load { ptr, ptr, i64, [2 x i64], [2 x i64] }, ptr %loadgep_.reloaded101, align 8
- %5 = load { ptr, ptr, i64, [2 x i64], [2 x i64] }, ptr %loadgep_.reloaded102, align 8
- br label %omp.region.after_alloca72
-
-omp.region.after_alloca72: ; preds = %omp.par.entry62
- br label %omp.region.after_alloca69
-
-omp.region.after_alloca69: ; preds = %omp.region.after_alloca72
- br label %omp.par.region63
-
-omp.par.region63: ; preds = %omp.region.after_alloca69
- br label %omp.par.region71
-
-omp.par.region71: ; preds = %omp.par.region63
- br label %omp_loop.preheader73
-
-omp_loop.preheader73: ; preds = %omp.par.region71
- store i64 0, ptr %p.lowerbound92, align 4
- store i64 499, ptr %p.upperbound93, align 4
- store i64 1, ptr %p.stride94, align 4
- %omp_global_thread_num95 = call i32 @__kmpc_global_thread_num(ptr @1)
- call void @__kmpc_for_static_init_8u(ptr @1, i32 %omp_global_thread_num95, i32 34, ptr %p.lastiter91, ptr %p.lowerbound92, ptr %p.upperbound93, ptr %p.stride94, i64 1, i64 0)
- %6 = load i64, ptr %p.lowerbound92, align 4
- %7 = load i64, ptr %p.upperbound93, align 4
- %8 = sub i64 %7, %6
- %9 = add i64 %8, 1
- br label %omp_loop.header74
-
-omp_loop.header74: ; preds = %omp_loop.inc77, %omp_loop.preheader73
- %omp_loop.iv80 = phi i64 [ 0, %omp_loop.preheader73 ], [ %omp_loop.next82, %omp_loop.inc77 ]
- br label %omp_loop.cond75
-
-omp_loop.cond75: ; preds = %omp_loop.header74
- %omp_loop.cmp81 = icmp ult i64 %omp_loop.iv80, %9
- br i1 %omp_loop.cmp81, label %omp_loop.body76, label %omp_loop.exit78
-
-omp_loop.exit78: ; preds = %omp_loop.cond75
- call void @__kmpc_for_static_fini(ptr @1, i32 %omp_global_thread_num95)
- %omp_global_thread_num96 = call i32 @__kmpc_global_thread_num(ptr @1)
- call void @__kmpc_barrier(ptr @2, i32 %omp_global_thread_num96)
- br label %omp_loop.after79
-
-omp_loop.after79: ; preds = %omp_loop.exit78
- br label %omp.region.cont70
-
-omp.region.cont70: ; preds = %omp_loop.after79
- br label %omp.par.pre_finalize64
-
-omp.par.pre_finalize64: ; preds = %omp.region.cont70
- br label %omp.par.outlined.exit98.exitStub
-
-omp_loop.body76: ; preds = %omp_loop.cond75
- %10 = add i64 %omp_loop.iv80, %6
- %11 = mul i64 %10, 1
- %12 = add i64 %11, 500
- br label %omp.wsloop.region84
-
-omp.wsloop.region84: ; preds = %omp_loop.body76
- br label %omp.wsloop.region85
-
-omp.wsloop.region85: ; preds = %omp.wsloop.region89, %omp.wsloop.region84
- %13 = phi i64 [ %25, %omp.wsloop.region89 ], [ 0, %omp.wsloop.region84 ]
- %14 = icmp slt i64 %13, 1000
- br i1 %14, label %omp.wsloop.region86, label %omp.wsloop.region90
-
-omp.wsloop.region90: ; preds = %omp.wsloop.region85
- br label %omp.region.cont83
-
-omp.region.cont83: ; preds = %omp.wsloop.region90
- br label %omp_loop.inc77
-
-omp_loop.inc77: ; preds = %omp.region.cont83
- %omp_loop.next82 = add nuw i64 %omp_loop.iv80, 1
- br label %omp_loop.header74
-
-omp.wsloop.region86: ; preds = %omp.wsloop.region85
+define internal void @kernel_2mm..omp_par.5(ptr noalias %tid.addr206, ptr noalias %zero.addr207, ptr %0) #0 {
+omp.par.entry208:
+ %gep_.reloaded248 = getelementptr { ptr, ptr, ptr, ptr }, ptr %0, i32 0, i32 0
+ %loadgep_.reloaded248 = load ptr, ptr %gep_.reloaded248, align 8, !align !1
+ %gep_.reloaded249 = getelementptr { ptr, ptr, ptr, ptr }, ptr %0, i32 0, i32 1
+ %loadgep_.reloaded249 = load ptr, ptr %gep_.reloaded249, align 8, !align !2
+ %gep_.reloaded250 = getelementptr { ptr, ptr, ptr, ptr }, ptr %0, i32 0, i32 2
+ %loadgep_.reloaded250 = load ptr, ptr %gep_.reloaded250, align 8, !align !1
+ %gep_ = getelementptr { ptr, ptr, ptr, ptr }, ptr %0, i32 0, i32 3
+ %loadgep_ = load ptr, ptr %gep_, align 8, !align !3
+ %p.lastiter242 = alloca i32, align 4
+ %p.lowerbound243 = alloca i64, align 8
+ %p.upperbound244 = alloca i64, align 8
+ %p.stride245 = alloca i64, align 8
+ %tid.addr.local212 = alloca i32, align 4
+ %1 = load i32, ptr %tid.addr206, align 4
+ store i32 %1, ptr %tid.addr.local212, align 4
+ %tid213 = load i32, ptr %tid.addr.local212, align 4
+ %2 = load { ptr, ptr, i64, [2 x i64], [2 x i64] }, ptr %loadgep_.reloaded248, align 8
+ %3 = load float, ptr %loadgep_.reloaded249, align 4
+ %4 = load { ptr, ptr, i64, [2 x i64], [2 x i64] }, ptr %loadgep_.reloaded250, align 8
+ br label %omp.region.after_alloca219
+
+omp.region.after_alloca219: ; preds = %omp.par.entry208
+ br label %omp.region.after_alloca216
+
+omp.region.after_alloca216: ; preds = %omp.region.after_alloca219
+ br label %omp.par.region209
+
+omp.par.region209: ; preds = %omp.region.after_alloca216
+ br label %omp.par.region218
+
+omp.par.region218: ; preds = %omp.par.region209
+ br label %omp.wsloop.region221
+
+omp.wsloop.region221: ; preds = %omp.par.region218
+ br label %omp_loop.preheader222
+
+omp_loop.preheader222: ; preds = %omp.wsloop.region221
+ store i64 0, ptr %p.lowerbound243, align 4
+ store i64 2499, ptr %p.upperbound244, align 4
+ store i64 1, ptr %p.stride245, align 4
+ %omp_global_thread_num246 = call i32 @__kmpc_global_thread_num(ptr @1)
+ call void @__kmpc_for_static_init_8u(ptr @1, i32 %omp_global_thread_num246, i32 34, ptr %p.lastiter242, ptr %p.lowerbound243, ptr %p.upperbound244, ptr %p.stride245, i64 1, i64 0)
+ %5 = load i64, ptr %p.lowerbound243, align 4
+ %6 = load i64, ptr %p.upperbound244, align 4
+ %7 = sub i64 %6, %5
+ %8 = add i64 %7, 1
+ br label %omp_loop.header223
+
+omp_loop.header223: ; preds = %omp_loop.inc226, %omp_loop.preheader222
+ %omp_loop.iv229 = phi i64 [ 0, %omp_loop.preheader222 ], [ %omp_loop.next231, %omp_loop.inc226 ]
+ br label %omp_loop.cond224
+
+omp_loop.cond224: ; preds = %omp_loop.header223
+ %omp_loop.cmp230 = icmp ult i64 %omp_loop.iv229, %8
+ br i1 %omp_loop.cmp230, label %omp_loop.body225, label %omp_loop.exit227
+
+omp_loop.exit227: ; preds = %omp_loop.cond224
+ call void @__kmpc_for_static_fini(ptr @1, i32 %omp_global_thread_num246)
+ %omp_global_thread_num247 = call i32 @__kmpc_global_thread_num(ptr @1)
+ call void @__kmpc_barrier(ptr @2, i32 %omp_global_thread_num247)
+ br label %omp_loop.after228
+
+omp_loop.after228: ; preds = %omp_loop.exit227
+ br label %omp.region.cont220
+
+omp.region.cont220: ; preds = %omp_loop.after228
+ br label %omp.region.cont217
+
+omp.region.cont217: ; preds = %omp.region.cont220
+ br label %omp.par.pre_finalize210
+
+omp.par.pre_finalize210: ; preds = %omp.region.cont217
+ br label %.fini251
+
+.fini251: ; preds = %omp.par.pre_finalize210
+ br label %omp.par.exit211.exitStub
+
+omp_loop.body225: ; preds = %omp_loop.cond224
+ %9 = add i64 %omp_loop.iv229, %5
+ %10 = mul i64 %9, 1
+ %11 = add i64 %10, 0
+ br label %omp.loop_nest.region233
+
+omp.loop_nest.region233: ; preds = %omp_loop.body225
+ %12 = call ptr @llvm.stacksave.p0()
+ br label %omp.loop_nest.region234
+
+omp.loop_nest.region234: ; preds = %omp.loop_nest.region233
+ br label %omp.loop_nest.region235
+
+omp.loop_nest.region235: ; preds = %omp.loop_nest.region239, %omp.loop_nest.region234
+ %13 = phi i64 [ %29, %omp.loop_nest.region239 ], [ 0, %omp.loop_nest.region234 ]
+ %14 = icmp slt i64 %13, 10000
+ br i1 %14, label %omp.loop_nest.region236, label %omp.loop_nest.region240
+
+omp.loop_nest.region240: ; preds = %omp.loop_nest.region235
+ call void @llvm.stackrestore.p0(ptr %12)
+ br label %omp.loop_nest.region241
+
+omp.loop_nest.region241: ; preds = %omp.loop_nest.region240
+ br label %omp.region.cont232
+
+omp.region.cont232: ; preds = %omp.loop_nest.region241
+ br label %omp_loop.inc226
+
+omp_loop.inc226: ; preds = %omp.region.cont232
+ %omp_loop.next231 = add nuw i64 %omp_loop.iv229, 1
+ br label %omp_loop.header223
+
+omp.loop_nest.region236: ; preds = %omp.loop_nest.region235
%15 = extractvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } %2, 1
- %16 = add nuw nsw i64 0, %13
- %17 = getelementptr float, ptr %15, i64 %16
- %18 = load float, ptr %17, align 4
- %19 = fmul float %18, %3
- %20 = extractvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } %2, 1
- %21 = add nuw nsw i64 0, %13
- %22 = getelementptr float, ptr %20, i64 %21
- store float %19, ptr %22, align 4
- br label %omp.wsloop.region87
-
-omp.wsloop.region87: ; preds = %omp.wsloop.region88, %omp.wsloop.region86
- %23 = phi i64 [ %44, %omp.wsloop.region88 ], [ 0, %omp.wsloop.region86 ]
- %24 = icmp slt i64 %23, 1000
- br i1 %24, label %omp.wsloop.region88, label %omp.wsloop.region89
-
-omp.wsloop.region89: ; preds = %omp.wsloop.region87
- %25 = add i64 %13, 1
- br label %omp.wsloop.region85
-
-omp.wsloop.region88: ; preds = %omp.wsloop.region87
- %26 = extractvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } %4, 1
- %27 = add nuw nsw i64 0, %23
- %28 = getelementptr float, ptr %26, i64 %27
- %29 = load float, ptr %28, align 4
- %30 = extractvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } %5, 1
- %31 = mul nuw nsw i64 %23, 1000
- %32 = add nuw nsw i64 %31, %13
- %33 = getelementptr float, ptr %30, i64 %32
- %34 = load float, ptr %33, align 4
- %35 = fmul float %29, %34
- %36 = extractvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } %2, 1
- %37 = add nuw nsw i64 0, %13
- %38 = getelementptr float, ptr %36, i64 %37
+ %16 = getelementptr float, ptr %15, i32 25000000
+ %17 = mul nuw nsw i64 %11, 10000
+ %18 = add nuw nsw i64 %17, %13
+ %19 = getelementptr inbounds nuw float, ptr %16, i64 %18
+ %20 = load float, ptr %19, align 4
+ %21 = fmul float %20, %3
+ %22 = extractvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } %2, 1
+ %23 = getelementptr float, ptr %22, i32 25000000
+ %24 = mul nuw nsw i64 %11, 10000
+ %25 = add nuw nsw i64 %24, %13
+ %26 = getelementptr inbounds nuw float, ptr %23, i64 %25
+ store float %21, ptr %26, align 4
+ br label %omp.loop_nest.region237
+
+omp.loop_nest.region237: ; preds = %omp.loop_nest.region238, %omp.loop_nest.region236
+ %27 = phi i64 [ %53, %omp.loop_nest.region238 ], [ 0, %omp.loop_nest.region236 ]
+ %28 = icmp slt i64 %27, 10000
+ br i1 %28, label %omp.loop_nest.region238, label %omp.loop_nest.region239
+
+omp.loop_nest.region239: ; preds = %omp.loop_nest.region237
+ %29 = add i64 %13, 1
+ br label %omp.loop_nest.region235
+
+omp.loop_nest.region238: ; preds = %omp.loop_nest.region237
+ %30 = extractvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } %4, 1
+ %31 = getelementptr float, ptr %30, i32 25000000
+ %32 = mul nuw nsw i64 %11, 10000
+ %33 = add nuw nsw i64 %32, %27
+ %34 = getelementptr inbounds nuw float, ptr %31, i64 %33
+ %35 = load float, ptr %34, align 4
+ %36 = mul nuw nsw i64 %27, 10000
+ %37 = add nuw nsw i64 %36, %13
+ %38 = getelementptr inbounds nuw float, ptr %loadgep_, i64 %37
%39 = load float, ptr %38, align 4
- %40 = fadd float %39, %35
+ %40 = fmul float %35, %39
%41 = extractvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } %2, 1
- %42 = add nuw nsw i64 0, %13
- %43 = getelementptr float, ptr %41, i64 %42
- store float %40, ptr %43, align 4
- %44 = add i64 %23, 1
- br label %omp.wsloop.region87
+ %42 = getelementptr float, ptr %41, i32 25000000
+ %43 = mul nuw nsw i64 %11, 10000
+ %44 = add nuw nsw i64 %43, %13
+ %45 = getelementptr inbounds nuw float, ptr %42, i64 %44
+ %46 = load float, ptr %45, align 4
+ %47 = fadd float %46, %40
+ %48 = extractvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } %2, 1
+ %49 = getelementptr float, ptr %48, i32 25000000
+ %50 = mul nuw nsw i64 %11, 10000
+ %51 = add nuw nsw i64 %50, %13
+ %52 = getelementptr inbounds nuw float, ptr %49, i64 %51
+ store float %47, ptr %52, align 4
+ %53 = add i64 %27, 1
+ br label %omp.loop_nest.region237
+
+omp.par.exit211.exitStub: ; preds = %.fini251
+ ret void
+}
+
+; Function Attrs: nounwind
+define internal void @kernel_2mm..omp_par.4(ptr noalias %tid.addr159, ptr noalias %zero.addr160, ptr %0) #0 {
+omp.par.entry161:
+ %gep_.reloaded201 = getelementptr { ptr, ptr, ptr, ptr }, ptr %0, i32 0, i32 0
+ %loadgep_.reloaded201 = load ptr, ptr %gep_.reloaded201, align 8, !align !1
+ %gep_.reloaded202 = getelementptr { ptr, ptr, ptr, ptr }, ptr %0, i32 0, i32 1
+ %loadgep_.reloaded202 = load ptr, ptr %gep_.reloaded202, align 8, !align !2
+ %gep_.reloaded203 = getelementptr { ptr, ptr, ptr, ptr }, ptr %0, i32 0, i32 2
+ %loadgep_.reloaded203 = load ptr, ptr %gep_.reloaded203, align 8, !align !1
+ %gep_ = getelementptr { ptr, ptr, ptr, ptr }, ptr %0, i32 0, i32 3
+ %loadgep_ = load ptr, ptr %gep_, align 8, !align !3
+ %p.lastiter195 = alloca i32, align 4
+ %p.lowerbound196 = alloca i64, align 8
+ %p.upperbound197 = alloca i64, align 8
+ %p.stride198 = alloca i64, align 8
+ %tid.addr.local165 = alloca i32, align 4
+ %1 = load i32, ptr %tid.addr159, align 4
+ store i32 %1, ptr %tid.addr.local165, align 4
+ %tid166 = load i32, ptr %tid.addr.local165, align 4
+ %2 = load { ptr, ptr, i64, [2 x i64], [2 x i64] }, ptr %loadgep_.reloaded201, align 8
+ %3 = load float, ptr %loadgep_.reloaded202, align 4
+ %4 = load { ptr, ptr, i64, [2 x i64], [2 x i64] }, ptr %loadgep_.reloaded203, align 8
+ br label %omp.region.after_alloca172
+
+omp.region.after_alloca172: ; preds = %omp.par.entry161
+ br label %omp.region.after_alloca169
+
+omp.region.after_alloca169: ; preds = %omp.region.after_alloca172
+ br label %omp.par.region162
+
+omp.par.region162: ; preds = %omp.region.after_alloca169
+ br label %omp.par.region171
+
+omp.par.region171: ; preds = %omp.par.region162
+ br label %omp.wsloop.region174
+
+omp.wsloop.region174: ; preds = %omp.par.region171
+ br label %omp_loop.preheader175
+
+omp_loop.preheader175: ; preds = %omp.wsloop.region174
+ store i64 0, ptr %p.lowerbound196, align 4
+ store i64 2499, ptr %p.upperbound197, align 4
+ store i64 1, ptr %p.stride198, align 4
+ %omp_global_thread_num199 = call i32 @__kmpc_global_thread_num(ptr @1)
+ call void @__kmpc_for_static_init_8u(ptr @1, i32 %omp_global_thread_num199, i32 34, ptr %p.lastiter195, ptr %p.lowerbound196, ptr %p.upperbound197, ptr %p.stride198, i64 1, i64 0)
+ %5 = load i64, ptr %p.lowerbound196, align 4
+ %6 = load i64, ptr %p.upperbound197, align 4
+ %7 = sub i64 %6, %5
+ %8 = add i64 %7, 1
+ br label %omp_loop.header176
+
+omp_loop.header176: ; preds = %omp_loop.inc179, %omp_loop.preheader175
+ %omp_loop.iv182 = phi i64 [ 0, %omp_loop.preheader175 ], [ %omp_loop.next184, %omp_loop.inc179 ]
+ br label %omp_loop.cond177
+
+omp_loop.cond177: ; preds = %omp_loop.header176
+ %omp_loop.cmp183 = icmp ult i64 %omp_loop.iv182, %8
+ br i1 %omp_loop.cmp183, label %omp_loop.body178, label %omp_loop.exit180
+
+omp_loop.exit180: ; preds = %omp_loop.cond177
+ call void @__kmpc_for_static_fini(ptr @1, i32 %omp_global_thread_num199)
+ %omp_global_thread_num200 = call i32 @__kmpc_global_thread_num(ptr @1)
+ call void @__kmpc_barrier(ptr @2, i32 %omp_global_thread_num200)
+ br label %omp_loop.after181
+
+omp_loop.after181: ; preds = %omp_loop.exit180
+ br label %omp.region.cont173
+
+omp.region.cont173: ; preds = %omp_loop.after181
+ br label %omp.region.cont170
+
+omp.region.cont170: ; preds = %omp.region.cont173
+ br label %omp.par.pre_finalize163
+
+omp.par.pre_finalize163: ; preds = %omp.region.cont170
+ br label %.fini204
+
+.fini204: ; preds = %omp.par.pre_finalize163
+ br label %omp.par.exit164.exitStub
+
+omp_loop.body178: ; preds = %omp_loop.cond177
+ %9 = add i64 %omp_loop.iv182, %5
+ %10 = mul i64 %9, 1
+ %11 = add i64 %10, 0
+ br label %omp.loop_nest.region186
+
+omp.loop_nest.region186: ; preds = %omp_loop.body178
+ %12 = call ptr @llvm.stacksave.p0()
+ br label %omp.loop_nest.region187
+
+omp.loop_nest.region187: ; preds = %omp.loop_nest.region186
+ br label %omp.loop_nest.region188
+
+omp.loop_nest.region188: ; preds = %omp.loop_nest.region192, %omp.loop_nest.region187
+ %13 = phi i64 [ %27, %omp.loop_nest.region192 ], [ 0, %omp.loop_nest.region187 ]
+ %14 = icmp slt i64 %13, 10000
+ br i1 %14, label %omp.loop_nest.region189, label %omp.loop_nest.region193
+
+omp.loop_nest.region193: ; preds = %omp.loop_nest.region188
+ call void @llvm.stackrestore.p0(ptr %12)
+ br label %omp.loop_nest.region194
+
+omp.loop_nest.region194: ; preds = %omp.loop_nest.region193
+ br label %omp.region.cont185
+
+omp.region.cont185: ; preds = %omp.loop_nest.region194
+ br label %omp_loop.inc179
+
+omp_loop.inc179: ; preds = %omp.region.cont185
+ %omp_loop.next184 = add nuw i64 %omp_loop.iv182, 1
+ br label %omp_loop.header176
+
+omp.loop_nest.region189: ; preds = %omp.loop_nest.region188
+ %15 = extractvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } %2, 1
+ %16 = mul nuw nsw i64 %11, 10000
+ %17 = add nuw nsw i64 %16, %13
+ %18 = getelementptr inbounds nuw float, ptr %15, i64 %17
+ %19 = load float, ptr %18, align 4
+ %20 = fmul float %19, %3
+ %21 = extractvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } %2, 1
+ %22 = mul nuw nsw i64 %11, 10000
+ %23 = add nuw nsw i64 %22, %13
+ %24 = getelementptr inbounds nuw float, ptr %21, i64 %23
+ store float %20, ptr %24, align 4
+ br label %omp.loop_nest.region190
+
+omp.loop_nest.region190: ; preds = %omp.loop_nest.region191, %omp.loop_nest.region189
+ %25 = phi i64 [ %48, %omp.loop_nest.region191 ], [ 0, %omp.loop_nest.region189 ]
+ %26 = icmp slt i64 %25, 10000
+ br i1 %26, label %omp.loop_nest.region191, label %omp.loop_nest.region192
+
+omp.loop_nest.region192: ; preds = %omp.loop_nest.region190
+ %27 = add i64 %13, 1
+ br label %omp.loop_nest.region188
+
+omp.loop_nest.region191: ; preds = %omp.loop_nest.region190
+ %28 = extractvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } %4, 1
+ %29 = mul nuw nsw i64 %11, 10000
+ %30 = add nuw nsw i64 %29, %25
+ %31 = getelementptr inbounds nuw float, ptr %28, i64 %30
+ %32 = load float, ptr %31, align 4
+ %33 = mul nuw nsw i64 %25, 10000
+ %34 = add nuw nsw i64 %33, %13
+ %35 = getelementptr inbounds nuw float, ptr %loadgep_, i64 %34
+ %36 = load float, ptr %35, align 4
+ %37 = fmul float %32, %36
+ %38 = extractvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } %2, 1
+ %39 = mul nuw nsw i64 %11, 10000
+ %40 = add nuw nsw i64 %39, %13
+ %41 = getelementptr inbounds nuw float, ptr %38, i64 %40
+ %42 = load float, ptr %41, align 4
+ %43 = fadd float %42, %37
+ %44 = extractvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } %2, 1
+ %45 = mul nuw nsw i64 %11, 10000
+ %46 = add nuw nsw i64 %45, %13
+ %47 = getelementptr inbounds nuw float, ptr %44, i64 %46
+ store float %43, ptr %47, align 4
+ %48 = add i64 %25, 1
+ br label %omp.loop_nest.region190
+
+omp.par.exit164.exitStub: ; preds = %.fini204
+ ret void
+}
+
+; Function Attrs: nounwind
+define internal void @kernel_2mm..omp_par.3(ptr noalias %tid.addr112, ptr noalias %zero.addr113, ptr %0) #0 {
+omp.par.entry114:
+ %gep_.reloaded154 = getelementptr { ptr, ptr, ptr, ptr }, ptr %0, i32 0, i32 0
+ %loadgep_.reloaded154 = load ptr, ptr %gep_.reloaded154, align 8, !align !1
+ %gep_.reloaded155 = getelementptr { ptr, ptr, ptr, ptr }, ptr %0, i32 0, i32 1
+ %loadgep_.reloaded155 = load ptr, ptr %gep_.reloaded155, align 8, !align !1
+ %gep_.reloaded156 = getelementptr { ptr, ptr, ptr, ptr }, ptr %0, i32 0, i32 2
+ %loadgep_.reloaded156 = load ptr, ptr %gep_.reloaded156, align 8, !align !2
+ %gep_ = getelementptr { ptr, ptr, ptr, ptr }, ptr %0, i32 0, i32 3
+ %loadgep_ = load ptr, ptr %gep_, align 8, !align !3
+ %p.lastiter148 = alloca i32, align 4
+ %p.lowerbound149 = alloca i64, align 8
+ %p.upperbound150 = alloca i64, align 8
+ %p.stride151 = alloca i64, align 8
+ %tid.addr.local118 = alloca i32, align 4
+ %1 = load i32, ptr %tid.addr112, align 4
+ store i32 %1, ptr %tid.addr.local118, align 4
+ %tid119 = load i32, ptr %tid.addr.local118, align 4
+ %2 = load { ptr, ptr, i64, [2 x i64], [2 x i64] }, ptr %loadgep_.reloaded154, align 8
+ %3 = load { ptr, ptr, i64, [2 x i64], [2 x i64] }, ptr %loadgep_.reloaded155, align 8
+ %4 = load float, ptr %loadgep_.reloaded156, align 4
+ br label %omp.region.after_alloca125
+
+omp.region.after_alloca125: ; preds = %omp.par.entry114
+ br label %omp.region.after_alloca122
+
+omp.region.after_alloca122: ; preds = %omp.region.after_alloca125
+ br label %omp.par.region115
+
+omp.par.region115: ; preds = %omp.region.after_alloca122
+ br label %omp.par.region124
+
+omp.par.region124: ; preds = %omp.par.region115
+ br label %omp.wsloop.region127
+
+omp.wsloop.region127: ; preds = %omp.par.region124
+ br label %omp_loop.preheader128
+
+omp_loop.preheader128: ; preds = %omp.wsloop.region127
+ store i64 0, ptr %p.lowerbound149, align 4
+ store i64 2499, ptr %p.upperbound150, align 4
+ store i64 1, ptr %p.stride151, align 4
+ %omp_global_thread_num152 = call i32 @__kmpc_global_thread_num(ptr @1)
+ call void @__kmpc_for_static_init_8u(ptr @1, i32 %omp_global_thread_num152, i32 34, ptr %p.lastiter148, ptr %p.lowerbound149, ptr %p.upperbound150, ptr %p.stride151, i64 1, i64 0)
+ %5 = load i64, ptr %p.lowerbound149, align 4
+ %6 = load i64, ptr %p.upperbound150, align 4
+ %7 = sub i64 %6, %5
+ %8 = add i64 %7, 1
+ br label %omp_loop.header129
+
+omp_loop.header129: ; preds = %omp_loop.inc132, %omp_loop.preheader128
+ %omp_loop.iv135 = phi i64 [ 0, %omp_loop.preheader128 ], [ %omp_loop.next137, %omp_loop.inc132 ]
+ br label %omp_loop.cond130
+
+omp_loop.cond130: ; preds = %omp_loop.header129
+ %omp_loop.cmp136 = icmp ult i64 %omp_loop.iv135, %8
+ br i1 %omp_loop.cmp136, label %omp_loop.body131, label %omp_loop.exit133
+
+omp_loop.exit133: ; preds = %omp_loop.cond130
+ call void @__kmpc_for_static_fini(ptr @1, i32 %omp_global_thread_num152)
+ %omp_global_thread_num153 = call i32 @__kmpc_global_thread_num(ptr @1)
+ call void @__kmpc_barrier(ptr @2, i32 %omp_global_thread_num153)
+ br label %omp_loop.after134
+
+omp_loop.after134: ; preds = %omp_loop.exit133
+ br label %omp.region.cont126
+
+omp.region.cont126: ; preds = %omp_loop.after134
+ br label %omp.region.cont123
+
+omp.region.cont123: ; preds = %omp.region.cont126
+ br label %omp.par.pre_finalize116
-omp.par.outlined.exit98.exitStub: ; preds = %omp.par.pre_finalize64
+omp.par.pre_finalize116: ; preds = %omp.region.cont123
+ br label %.fini157
+
+.fini157: ; preds = %omp.par.pre_finalize116
+ br label %omp.par.exit117.exitStub
+
+omp_loop.body131: ; preds = %omp_loop.cond130
+ %9 = add i64 %omp_loop.iv135, %5
+ %10 = mul i64 %9, 1
+ %11 = add i64 %10, 0
+ br label %omp.loop_nest.region139
+
+omp.loop_nest.region139: ; preds = %omp_loop.body131
+ %12 = call ptr @llvm.stacksave.p0()
+ br label %omp.loop_nest.region140
+
+omp.loop_nest.region140: ; preds = %omp.loop_nest.region139
+ br label %omp.loop_nest.region141
+
+omp.loop_nest.region141: ; preds = %omp.loop_nest.region145, %omp.loop_nest.region140
+ %13 = phi i64 [ %22, %omp.loop_nest.region145 ], [ 0, %omp.loop_nest.region140 ]
+ %14 = icmp slt i64 %13, 10000
+ br i1 %14, label %omp.loop_nest.region142, label %omp.loop_nest.region146
+
+omp.loop_nest.region146: ; preds = %omp.loop_nest.region141
+ call void @llvm.stackrestore.p0(ptr %12)
+ br label %omp.loop_nest.region147
+
+omp.loop_nest.region147: ; preds = %omp.loop_nest.region146
+ br label %omp.region.cont138
+
+omp.region.cont138: ; preds = %omp.loop_nest.region147
+ br label %omp_loop.inc132
+
+omp_loop.inc132: ; preds = %omp.region.cont138
+ %omp_loop.next137 = add nuw i64 %omp_loop.iv135, 1
+ br label %omp_loop.header129
+
+omp.loop_nest.region142: ; preds = %omp.loop_nest.region141
+ %15 = extractvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } %2, 1
+ %16 = getelementptr float, ptr %15, i32 75000000
+ %17 = mul nuw nsw i64 %11, 10000
+ %18 = add nuw nsw i64 %17, %13
+ %19 = getelementptr inbounds nuw float, ptr %16, i64 %18
+ store float 0.000000e+00, ptr %19, align 4
+ br label %omp.loop_nest.region143
+
+omp.loop_nest.region143: ; preds = %omp.loop_nest.region144, %omp.loop_nest.region142
+ %20 = phi i64 [ %47, %omp.loop_nest.region144 ], [ 0, %omp.loop_nest.region142 ]
+ %21 = icmp slt i64 %20, 10000
+ br i1 %21, label %omp.loop_nest.region144, label %omp.loop_nest.region145
+
+omp.loop_nest.region145: ; preds = %omp.loop_nest.region143
+ %22 = add i64 %13, 1
+ br label %omp.loop_nest.region141
+
+omp.loop_nest.region144: ; preds = %omp.loop_nest.region143
+ %23 = extractvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } %3, 1
+ %24 = getelementptr float, ptr %23, i32 75000000
+ %25 = mul nuw nsw i64 %11, 10000
+ %26 = add nuw nsw i64 %25, %20
+ %27 = getelementptr inbounds nuw float, ptr %24, i64 %26
+ %28 = load float, ptr %27, align 4
+ %29 = fmul float %4, %28
+ %30 = mul nuw nsw i64 %20, 10000
+ %31 = add nuw nsw i64 %30, %13
+ %32 = getelementptr inbounds nuw float, ptr %loadgep_, i64 %31
+ %33 = load float, ptr %32, align 4
+ %34 = fmul float %29, %33
+ %35 = extractvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } %2, 1
+ %36 = getelementptr float, ptr %35, i32 75000000
+ %37 = mul nuw nsw i64 %11, 10000
+ %38 = add nuw nsw i64 %37, %13
+ %39 = getelementptr inbounds nuw float, ptr %36, i64 %38
+ %40 = load float, ptr %39, align 4
+ %41 = fadd float %40, %34
+ %42 = extractvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } %2, 1
+ %43 = getelementptr float, ptr %42, i32 75000000
+ %44 = mul nuw nsw i64 %11, 10000
+ %45 = add nuw nsw i64 %44, %13
+ %46 = getelementptr inbounds nuw float, ptr %43, i64 %45
+ store float %41, ptr %46, align 4
+ %47 = add i64 %20, 1
+ br label %omp.loop_nest.region143
+
+omp.par.exit117.exitStub: ; preds = %.fini157
+ ret void
+}
+
+; Function Attrs: nounwind
+define internal void @kernel_2mm..omp_par.2(ptr noalias %tid.addr65, ptr noalias %zero.addr66, ptr %0) #0 {
+omp.par.entry67:
+ %gep_.reloaded107 = getelementptr { ptr, ptr, ptr, ptr }, ptr %0, i32 0, i32 0
+ %loadgep_.reloaded107 = load ptr, ptr %gep_.reloaded107, align 8, !align !1
+ %gep_.reloaded108 = getelementptr { ptr, ptr, ptr, ptr }, ptr %0, i32 0, i32 1
+ %loadgep_.reloaded108 = load ptr, ptr %gep_.reloaded108, align 8, !align !1
+ %gep_.reloaded109 = getelementptr { ptr, ptr, ptr, ptr }, ptr %0, i32 0, i32 2
+ %loadgep_.reloaded109 = load ptr, ptr %gep_.reloaded109, align 8, !align !2
+ %gep_ = getelementptr { ptr, ptr, ptr, ptr }, ptr %0, i32 0, i32 3
+ %loadgep_ = load ptr, ptr %gep_, align 8, !align !3
+ %p.lastiter101 = alloca i32, align 4
+ %p.lowerbound102 = alloca i64, align 8
+ %p.upperbound103 = alloca i64, align 8
+ %p.stride104 = alloca i64, align 8
+ %tid.addr.local71 = alloca i32, align 4
+ %1 = load i32, ptr %tid.addr65, align 4
+ store i32 %1, ptr %tid.addr.local71, align 4
+ %tid72 = load i32, ptr %tid.addr.local71, align 4
+ %2 = load { ptr, ptr, i64, [2 x i64], [2 x i64] }, ptr %loadgep_.reloaded107, align 8
+ %3 = load { ptr, ptr, i64, [2 x i64], [2 x i64] }, ptr %loadgep_.reloaded108, align 8
+ %4 = load float, ptr %loadgep_.reloaded109, align 4
+ br label %omp.region.after_alloca78
+
+omp.region.after_alloca78: ; preds = %omp.par.entry67
+ br label %omp.region.after_alloca75
+
+omp.region.after_alloca75: ; preds = %omp.region.after_alloca78
+ br label %omp.par.region68
+
+omp.par.region68: ; preds = %omp.region.after_alloca75
+ br label %omp.par.region77
+
+omp.par.region77: ; preds = %omp.par.region68
+ br label %omp.wsloop.region80
+
+omp.wsloop.region80: ; preds = %omp.par.region77
+ br label %omp_loop.preheader81
+
+omp_loop.preheader81: ; preds = %omp.wsloop.region80
+ store i64 0, ptr %p.lowerbound102, align 4
+ store i64 2499, ptr %p.upperbound103, align 4
+ store i64 1, ptr %p.stride104, align 4
+ %omp_global_thread_num105 = call i32 @__kmpc_global_thread_num(ptr @1)
+ call void @__kmpc_for_static_init_8u(ptr @1, i32 %omp_global_thread_num105, i32 34, ptr %p.lastiter101, ptr %p.lowerbound102, ptr %p.upperbound103, ptr %p.stride104, i64 1, i64 0)
+ %5 = load i64, ptr %p.lowerbound102, align 4
+ %6 = load i64, ptr %p.upperbound103, align 4
+ %7 = sub i64 %6, %5
+ %8 = add i64 %7, 1
+ br label %omp_loop.header82
+
+omp_loop.header82: ; preds = %omp_loop.inc85, %omp_loop.preheader81
+ %omp_loop.iv88 = phi i64 [ 0, %omp_loop.preheader81 ], [ %omp_loop.next90, %omp_loop.inc85 ]
+ br label %omp_loop.cond83
+
+omp_loop.cond83: ; preds = %omp_loop.header82
+ %omp_loop.cmp89 = icmp ult i64 %omp_loop.iv88, %8
+ br i1 %omp_loop.cmp89, label %omp_loop.body84, label %omp_loop.exit86
+
+omp_loop.exit86: ; preds = %omp_loop.cond83
+ call void @__kmpc_for_static_fini(ptr @1, i32 %omp_global_thread_num105)
+ %omp_global_thread_num106 = call i32 @__kmpc_global_thread_num(ptr @1)
+ call void @__kmpc_barrier(ptr @2, i32 %omp_global_thread_num106)
+ br label %omp_loop.after87
+
+omp_loop.after87: ; preds = %omp_loop.exit86
+ br label %omp.region.cont79
+
+omp.region.cont79: ; preds = %omp_loop.after87
+ br label %omp.region.cont76
+
+omp.region.cont76: ; preds = %omp.region.cont79
+ br label %omp.par.pre_finalize69
+
+omp.par.pre_finalize69: ; preds = %omp.region.cont76
+ br label %.fini110
+
+.fini110: ; preds = %omp.par.pre_finalize69
+ br label %omp.par.exit70.exitStub
+
+omp_loop.body84: ; preds = %omp_loop.cond83
+ %9 = add i64 %omp_loop.iv88, %5
+ %10 = mul i64 %9, 1
+ %11 = add i64 %10, 0
+ br label %omp.loop_nest.region92
+
+omp.loop_nest.region92: ; preds = %omp_loop.body84
+ %12 = call ptr @llvm.stacksave.p0()
+ br label %omp.loop_nest.region93
+
+omp.loop_nest.region93: ; preds = %omp.loop_nest.region92
+ br label %omp.loop_nest.region94
+
+omp.loop_nest.region94: ; preds = %omp.loop_nest.region98, %omp.loop_nest.region93
+ %13 = phi i64 [ %22, %omp.loop_nest.region98 ], [ 0, %omp.loop_nest.region93 ]
+ %14 = icmp slt i64 %13, 10000
+ br i1 %14, label %omp.loop_nest.region95, label %omp.loop_nest.region99
+
+omp.loop_nest.region99: ; preds = %omp.loop_nest.region94
+ call void @llvm.stackrestore.p0(ptr %12)
+ br label %omp.loop_nest.region100
+
+omp.loop_nest.region100: ; preds = %omp.loop_nest.region99
+ br label %omp.region.cont91
+
+omp.region.cont91: ; preds = %omp.loop_nest.region100
+ br label %omp_loop.inc85
+
+omp_loop.inc85: ; preds = %omp.region.cont91
+ %omp_loop.next90 = add nuw i64 %omp_loop.iv88, 1
+ br label %omp_loop.header82
+
+omp.loop_nest.region95: ; preds = %omp.loop_nest.region94
+ %15 = extractvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } %2, 1
+ %16 = getelementptr float, ptr %15, i32 50000000
+ %17 = mul nuw nsw i64 %11, 10000
+ %18 = add nuw nsw i64 %17, %13
+ %19 = getelementptr inbounds nuw float, ptr %16, i64 %18
+ store float 0.000000e+00, ptr %19, align 4
+ br label %omp.loop_nest.region96
+
+omp.loop_nest.region96: ; preds = %omp.loop_nest.region97, %omp.loop_nest.region95
+ %20 = phi i64 [ %47, %omp.loop_nest.region97 ], [ 0, %omp.loop_nest.region95 ]
+ %21 = icmp slt i64 %20, 10000
+ br i1 %21, label %omp.loop_nest.region97, label %omp.loop_nest.region98
+
+omp.loop_nest.region98: ; preds = %omp.loop_nest.region96
+ %22 = add i64 %13, 1
+ br label %omp.loop_nest.region94
+
+omp.loop_nest.region97: ; preds = %omp.loop_nest.region96
+ %23 = extractvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } %3, 1
+ %24 = getelementptr float, ptr %23, i32 50000000
+ %25 = mul nuw nsw i64 %11, 10000
+ %26 = add nuw nsw i64 %25, %20
+ %27 = getelementptr inbounds nuw float, ptr %24, i64 %26
+ %28 = load float, ptr %27, align 4
+ %29 = fmul float %4, %28
+ %30 = mul nuw nsw i64 %20, 10000
+ %31 = add nuw nsw i64 %30, %13
+ %32 = getelementptr inbounds nuw float, ptr %loadgep_, i64 %31
+ %33 = load float, ptr %32, align 4
+ %34 = fmul float %29, %33
+ %35 = extractvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } %2, 1
+ %36 = getelementptr float, ptr %35, i32 50000000
+ %37 = mul nuw nsw i64 %11, 10000
+ %38 = add nuw nsw i64 %37, %13
+ %39 = getelementptr inbounds nuw float, ptr %36, i64 %38
+ %40 = load float, ptr %39, align 4
+ %41 = fadd float %40, %34
+ %42 = extractvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } %2, 1
+ %43 = getelementptr float, ptr %42, i32 50000000
+ %44 = mul nuw nsw i64 %11, 10000
+ %45 = add nuw nsw i64 %44, %13
+ %46 = getelementptr inbounds nuw float, ptr %43, i64 %45
+ store float %41, ptr %46, align 4
+ %47 = add i64 %20, 1
+ br label %omp.loop_nest.region96
+
+omp.par.exit70.exitStub: ; preds = %.fini110
ret void
}
; Function Attrs: nounwind
-define internal void @testFunc..omp_par.1(ptr noalias %tid.addr16, ptr noalias %zero.addr17, ptr %0) #0 {
-omp.par.entry18:
- %gep_.reloaded55 = getelementptr { ptr, ptr, ptr, ptr }, ptr %0, i32 0, i32 0
- %loadgep_.reloaded55 = load ptr, ptr %gep_.reloaded55, align 8
- %gep_.reloaded56 = getelementptr { ptr, ptr, ptr, ptr }, ptr %0, i32 0, i32 1
- %loadgep_.reloaded56 = load ptr, ptr %gep_.reloaded56, align 8
- %gep_.reloaded57 = getelementptr { ptr, ptr, ptr, ptr }, ptr %0, i32 0, i32 2
- %loadgep_.reloaded57 = load ptr, ptr %gep_.reloaded57, align 8
- %gep_.reloaded58 = getelementptr { ptr, ptr, ptr, ptr }, ptr %0, i32 0, i32 3
- %loadgep_.reloaded58 = load ptr, ptr %gep_.reloaded58, align 8
- %p.lastiter47 = alloca i32, align 4
- %p.lowerbound48 = alloca i64, align 8
- %p.upperbound49 = alloca i64, align 8
- %p.stride50 = alloca i64, align 8
- %tid.addr.local21 = alloca i32, align 4
- %1 = load i32, ptr %tid.addr16, align 4
- store i32 %1, ptr %tid.addr.local21, align 4
- %tid22 = load i32, ptr %tid.addr.local21, align 4
- %2 = load { ptr, ptr, i64, [2 x i64], [2 x i64] }, ptr %loadgep_.reloaded55, align 8
- %3 = load { ptr, ptr, i64, [2 x i64], [2 x i64] }, ptr %loadgep_.reloaded56, align 8
- %4 = load float, ptr %loadgep_.reloaded57, align 4
- %5 = load { ptr, ptr, i64, [2 x i64], [2 x i64] }, ptr %loadgep_.reloaded58, align 8
+define internal void @kernel_2mm..omp_par.1(ptr noalias %tid.addr18, ptr noalias %zero.addr19, ptr %0) #0 {
+omp.par.entry20:
+ %gep_.reloaded60 = getelementptr { ptr, ptr, ptr, ptr }, ptr %0, i32 0, i32 0
+ %loadgep_.reloaded60 = load ptr, ptr %gep_.reloaded60, align 8, !align !1
+ %gep_.reloaded61 = getelementptr { ptr, ptr, ptr, ptr }, ptr %0, i32 0, i32 1
+ %loadgep_.reloaded61 = load ptr, ptr %gep_.reloaded61, align 8, !align !1
+ %gep_.reloaded62 = getelementptr { ptr, ptr, ptr, ptr }, ptr %0, i32 0, i32 2
+ %loadgep_.reloaded62 = load ptr, ptr %gep_.reloaded62, align 8, !align !2
+ %gep_ = getelementptr { ptr, ptr, ptr, ptr }, ptr %0, i32 0, i32 3
+ %loadgep_ = load ptr, ptr %gep_, align 8, !align !3
+ %p.lastiter54 = alloca i32, align 4
+ %p.lowerbound55 = alloca i64, align 8
+ %p.upperbound56 = alloca i64, align 8
+ %p.stride57 = alloca i64, align 8
+ %tid.addr.local24 = alloca i32, align 4
+ %1 = load i32, ptr %tid.addr18, align 4
+ store i32 %1, ptr %tid.addr.local24, align 4
+ %tid25 = load i32, ptr %tid.addr.local24, align 4
+ %2 = load { ptr, ptr, i64, [2 x i64], [2 x i64] }, ptr %loadgep_.reloaded60, align 8
+ %3 = load { ptr, ptr, i64, [2 x i64], [2 x i64] }, ptr %loadgep_.reloaded61, align 8
+ %4 = load float, ptr %loadgep_.reloaded62, align 4
+ br label %omp.region.after_alloca31
+
+omp.region.after_alloca31: ; preds = %omp.par.entry20
br label %omp.region.after_alloca28
-omp.region.after_alloca28: ; preds = %omp.par.entry18
- br label %omp.region.after_alloca25
+omp.region.after_alloca28: ; preds = %omp.region.after_alloca31
+ br label %omp.par.region21
+
+omp.par.region21: ; preds = %omp.region.after_alloca28
+ br label %omp.par.region30
-omp.region.after_alloca25: ; preds = %omp.region.after_alloca28
- br label %omp.par.region19
+omp.par.region30: ; preds = %omp.par.region21
+ br label %omp.wsloop.region33
-omp.par.region19: ; preds = %omp.region.after_alloca25
- br label %omp.par.region27
+omp.wsloop.region33: ; preds = %omp.par.region30
+ br label %omp_loop.preheader34
-omp.par.region27: ; preds = %omp.par.region19
- br label %omp_loop.preheader29
+omp_loop.preheader34: ; preds = %omp.wsloop.region33
+ store i64 0, ptr %p.lowerbound55, align 4
+ store i64 2499, ptr %p.upperbound56, align 4
+ store i64 1, ptr %p.stride57, align 4
+ %omp_global_thread_num58 = call i32 @__kmpc_global_thread_num(ptr @1)
+ call void @__kmpc_for_static_init_8u(ptr @1, i32 %omp_global_thread_num58, i32 34, ptr %p.lastiter54, ptr %p.lowerbound55, ptr %p.upperbound56, ptr %p.stride57, i64 1, i64 0)
+ %5 = load i64, ptr %p.lowerbound55, align 4
+ %6 = load i64, ptr %p.upperbound56, align 4
+ %7 = sub i64 %6, %5
+ %8 = add i64 %7, 1
+ br label %omp_loop.header35
-omp_loop.preheader29: ; preds = %omp.par.region27
- store i64 0, ptr %p.lowerbound48, align 4
- store i64 499, ptr %p.upperbound49, align 4
- store i64 1, ptr %p.stride50, align 4
- %omp_global_thread_num51 = call i32 @__kmpc_global_thread_num(ptr @1)
- call void @__kmpc_for_static_init_8u(ptr @1, i32 %omp_global_thread_num51, i32 34, ptr %p.lastiter47, ptr %p.lowerbound48, ptr %p.upperbound49, ptr %p.stride50, i64 1, i64 0)
- %6 = load i64, ptr %p.lowerbound48, align 4
- %7 = load i64, ptr %p.upperbound49, align 4
- %8 = sub i64 %7, %6
- %9 = add i64 %8, 1
- br label %omp_loop.header30
+omp_loop.header35: ; preds = %omp_loop.inc38, %omp_loop.preheader34
+ %omp_loop.iv41 = phi i64 [ 0, %omp_loop.preheader34 ], [ %omp_loop.next43, %omp_loop.inc38 ]
+ br label %omp_loop.cond36
-omp_loop.header30: ; preds = %omp_loop.inc33, %omp_loop.preheader29
- %omp_loop.iv36 = phi i64 [ 0, %omp_loop.preheader29 ], [ %omp_loop.next38, %omp_loop.inc33 ]
- br label %omp_loop.cond31
+omp_loop.cond36: ; preds = %omp_loop.header35
+ %omp_loop.cmp42 = icmp ult i64 %omp_loop.iv41, %8
+ br i1 %omp_loop.cmp42, label %omp_loop.body37, label %omp_loop.exit39
-omp_loop.cond31: ; preds = %omp_loop.header30
- %omp_loop.cmp37 = icmp ult i64 %omp_loop.iv36, %9
- br i1 %omp_loop.cmp37, label %omp_loop.body32, label %omp_loop.exit34
+omp_loop.exit39: ; preds = %omp_loop.cond36
+ call void @__kmpc_for_static_fini(ptr @1, i32 %omp_global_thread_num58)
+ %omp_global_thread_num59 = call i32 @__kmpc_global_thread_num(ptr @1)
+ call void @__kmpc_barrier(ptr @2, i32 %omp_global_thread_num59)
+ br label %omp_loop.after40
+
+omp_loop.after40: ; preds = %omp_loop.exit39
+ br label %omp.region.cont32
+
+omp.region.cont32: ; preds = %omp_loop.after40
+ br label %omp.region.cont29
-omp_loop.exit34: ; preds = %omp_loop.cond31
- call void @__kmpc_for_static_fini(ptr @1, i32 %omp_global_thread_num51)
- %omp_global_thread_num52 = call i32 @__kmpc_global_thread_num(ptr @1)
- call void @__kmpc_barrier(ptr @2, i32 %omp_global_thread_num52)
- br label %omp_loop.after35
+omp.region.cont29: ; preds = %omp.region.cont32
+ br label %omp.par.pre_finalize22
-omp_loop.after35: ; preds = %omp_loop.exit34
- br label %omp.region.cont26
+omp.par.pre_finalize22: ; preds = %omp.region.cont29
+ br label %.fini63
-omp.region.cont26: ; preds = %omp_loop.after35
- br label %omp.par.pre_finalize20
+.fini63: ; preds = %omp.par.pre_finalize22
+ br label %omp.par.exit23.exitStub
-omp.par.pre_finalize20: ; preds = %omp.region.cont26
- br label %omp.par.outlined.exit54.exitStub
+omp_loop.body37: ; preds = %omp_loop.cond36
+ %9 = add i64 %omp_loop.iv41, %5
+ %10 = mul i64 %9, 1
+ %11 = add i64 %10, 0
+ br label %omp.loop_nest.region45
-omp_loop.body32: ; preds = %omp_loop.cond31
- %10 = add i64 %omp_loop.iv36, %6
- %11 = mul i64 %10, 1
- %12 = add i64 %11, 0
- br label %omp.wsloop.region40
+omp.loop_nest.region45: ; preds = %omp_loop.body37
+ %12 = call ptr @llvm.stacksave.p0()
+ br label %omp.loop_nest.region46
-omp.wsloop.region40: ; preds = %omp_loop.body32
- br label %omp.wsloop.region41
+omp.loop_nest.region46: ; preds = %omp.loop_nest.region45
+ br label %omp.loop_nest.region47
-omp.wsloop.region41: ; preds = %omp.wsloop.region45, %omp.wsloop.region40
- %13 = phi i64 [ %20, %omp.wsloop.region45 ], [ 0, %omp.wsloop.region40 ]
- %14 = icmp slt i64 %13, 1000
- br i1 %14, label %omp.wsloop.region42, label %omp.wsloop.region46
+omp.loop_nest.region47: ; preds = %omp.loop_nest.region51, %omp.loop_nest.region46
+ %13 = phi i64 [ %22, %omp.loop_nest.region51 ], [ 0, %omp.loop_nest.region46 ]
+ %14 = icmp slt i64 %13, 10000
+ br i1 %14, label %omp.loop_nest.region48, label %omp.loop_nest.region52
-omp.wsloop.region46: ; preds = %omp.wsloop.region41
- br label %omp.region.cont39
+omp.loop_nest.region52: ; preds = %omp.loop_nest.region47
+ call void @llvm.stackrestore.p0(ptr %12)
+ br label %omp.loop_nest.region53
-omp.region.cont39: ; preds = %omp.wsloop.region46
- br label %omp_loop.inc33
+omp.loop_nest.region53: ; preds = %omp.loop_nest.region52
+ br label %omp.region.cont44
-omp_loop.inc33: ; preds = %omp.region.cont39
- %omp_loop.next38 = add nuw i64 %omp_loop.iv36, 1
- br label %omp_loop.header30
+omp.region.cont44: ; preds = %omp.loop_nest.region53
+ br label %omp_loop.inc38
-omp.wsloop.region42: ; preds = %omp.wsloop.region41
+omp_loop.inc38: ; preds = %omp.region.cont44
+ %omp_loop.next43 = add nuw i64 %omp_loop.iv41, 1
+ br label %omp_loop.header35
+
+omp.loop_nest.region48: ; preds = %omp.loop_nest.region47
%15 = extractvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } %2, 1
- %16 = add nuw nsw i64 0, %13
- %17 = getelementptr float, ptr %15, i64 %16
- store float 0.000000e+00, ptr %17, align 4
- br label %omp.wsloop.region43
-
-omp.wsloop.region43: ; preds = %omp.wsloop.region44, %omp.wsloop.region42
- %18 = phi i64 [ %40, %omp.wsloop.region44 ], [ 0, %omp.wsloop.region42 ]
- %19 = icmp slt i64 %18, 1000
- br i1 %19, label %omp.wsloop.region44, label %omp.wsloop.region45
-
-omp.wsloop.region45: ; preds = %omp.wsloop.region43
- %20 = add i64 %13, 1
- br label %omp.wsloop.region41
-
-omp.wsloop.region44: ; preds = %omp.wsloop.region43
- %21 = extractvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } %3, 1
- %22 = add nuw nsw i64 0, %18
- %23 = getelementptr float, ptr %21, i64 %22
- %24 = load float, ptr %23, align 4
- %25 = fmul float %4, %24
- %26 = extractvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } %5, 1
- %27 = mul nuw nsw i64 %18, 1000
- %28 = add nuw nsw i64 %27, %13
- %29 = getelementptr float, ptr %26, i64 %28
- %30 = load float, ptr %29, align 4
- %31 = fmul float %25, %30
- %32 = extractvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } %2, 1
- %33 = add nuw nsw i64 0, %13
- %34 = getelementptr float, ptr %32, i64 %33
- %35 = load float, ptr %34, align 4
- %36 = fadd float %35, %31
- %37 = extractvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } %2, 1
- %38 = add nuw nsw i64 0, %13
- %39 = getelementptr float, ptr %37, i64 %38
- store float %36, ptr %39, align 4
- %40 = add i64 %18, 1
- br label %omp.wsloop.region43
-
-omp.par.outlined.exit54.exitStub: ; preds = %omp.par.pre_finalize20
+ %16 = getelementptr float, ptr %15, i32 25000000
+ %17 = mul nuw nsw i64 %11, 10000
+ %18 = add nuw nsw i64 %17, %13
+ %19 = getelementptr inbounds nuw float, ptr %16, i64 %18
+ store float 0.000000e+00, ptr %19, align 4
+ br label %omp.loop_nest.region49
+
+omp.loop_nest.region49: ; preds = %omp.loop_nest.region50, %omp.loop_nest.region48
+ %20 = phi i64 [ %47, %omp.loop_nest.region50 ], [ 0, %omp.loop_nest.region48 ]
+ %21 = icmp slt i64 %20, 10000
+ br i1 %21, label %omp.loop_nest.region50, label %omp.loop_nest.region51
+
+omp.loop_nest.region51: ; preds = %omp.loop_nest.region49
+ %22 = add i64 %13, 1
+ br label %omp.loop_nest.region47
+
+omp.loop_nest.region50: ; preds = %omp.loop_nest.region49
+ %23 = extractvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } %3, 1
+ %24 = getelementptr float, ptr %23, i32 25000000
+ %25 = mul nuw nsw i64 %11, 10000
+ %26 = add nuw nsw i64 %25, %20
+ %27 = getelementptr inbounds nuw float, ptr %24, i64 %26
+ %28 = load float, ptr %27, align 4
+ %29 = fmul float %4, %28
+ %30 = mul nuw nsw i64 %20, 10000
+ %31 = add nuw nsw i64 %30, %13
+ %32 = getelementptr inbounds nuw float, ptr %loadgep_, i64 %31
+ %33 = load float, ptr %32, align 4
+ %34 = fmul float %29, %33
+ %35 = extractvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } %2, 1
+ %36 = getelementptr float, ptr %35, i32 25000000
+ %37 = mul nuw nsw i64 %11, 10000
+ %38 = add nuw nsw i64 %37, %13
+ %39 = getelementptr inbounds nuw float, ptr %36, i64 %38
+ %40 = load float, ptr %39, align 4
+ %41 = fadd float %40, %34
+ %42 = extractvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } %2, 1
+ %43 = getelementptr float, ptr %42, i32 25000000
+ %44 = mul nuw nsw i64 %11, 10000
+ %45 = add nuw nsw i64 %44, %13
+ %46 = getelementptr inbounds nuw float, ptr %43, i64 %45
+ store float %41, ptr %46, align 4
+ %47 = add i64 %20, 1
+ br label %omp.loop_nest.region49
+
+omp.par.exit23.exitStub: ; preds = %.fini63
ret void
}
; Function Attrs: nounwind
-define internal void @testFunc..omp_par(ptr noalias %tid.addr, ptr noalias %zero.addr, ptr %0) #0 {
+define internal void @kernel_2mm..omp_par(ptr noalias %tid.addr, ptr noalias %zero.addr, ptr %0) #0 {
omp.par.entry:
%gep_.reloaded = getelementptr { ptr, ptr, ptr, ptr }, ptr %0, i32 0, i32 0
- %loadgep_.reloaded = load ptr, ptr %gep_.reloaded, align 8
- %gep_.reloaded12 = getelementptr { ptr, ptr, ptr, ptr }, ptr %0, i32 0, i32 1
- %loadgep_.reloaded12 = load ptr, ptr %gep_.reloaded12, align 8
- %gep_.reloaded13 = getelementptr { ptr, ptr, ptr, ptr }, ptr %0, i32 0, i32 2
- %loadgep_.reloaded13 = load ptr, ptr %gep_.reloaded13, align 8
- %gep_.reloaded14 = getelementptr { ptr, ptr, ptr, ptr }, ptr %0, i32 0, i32 3
- %loadgep_.reloaded14 = load ptr, ptr %gep_.reloaded14, align 8
+ %loadgep_.reloaded = load ptr, ptr %gep_.reloaded, align 8, !align !1
+ %gep_.reloaded15 = getelementptr { ptr, ptr, ptr, ptr }, ptr %0, i32 0, i32 1
+ %loadgep_.reloaded15 = load ptr, ptr %gep_.reloaded15, align 8, !align !1
+ %gep_.reloaded16 = getelementptr { ptr, ptr, ptr, ptr }, ptr %0, i32 0, i32 2
+ %loadgep_.reloaded16 = load ptr, ptr %gep_.reloaded16, align 8, !align !2
+ %gep_ = getelementptr { ptr, ptr, ptr, ptr }, ptr %0, i32 0, i32 3
+ %loadgep_ = load ptr, ptr %gep_, align 8, !align !3
%p.lastiter = alloca i32, align 4
%p.lowerbound = alloca i64, align 8
%p.upperbound = alloca i64, align 8
@@ -659,9 +2142,8 @@ omp.par.entry:
store i32 %1, ptr %tid.addr.local, align 4
%tid = load i32, ptr %tid.addr.local, align 4
%2 = load { ptr, ptr, i64, [2 x i64], [2 x i64] }, ptr %loadgep_.reloaded, align 8
- %3 = load { ptr, ptr, i64, [2 x i64], [2 x i64] }, ptr %loadgep_.reloaded12, align 8
- %4 = load float, ptr %loadgep_.reloaded13, align 4
- %5 = load { ptr, ptr, i64, [2 x i64], [2 x i64] }, ptr %loadgep_.reloaded14, align 8
+ %3 = load { ptr, ptr, i64, [2 x i64], [2 x i64] }, ptr %loadgep_.reloaded15, align 8
+ %4 = load float, ptr %loadgep_.reloaded16, align 4
br label %omp.region.after_alloca2
omp.region.after_alloca2: ; preds = %omp.par.entry
@@ -674,18 +2156,21 @@ omp.par.region: ; preds = %omp.region.after_al
br label %omp.par.region1
omp.par.region1: ; preds = %omp.par.region
+ br label %omp.wsloop.region
+
+omp.wsloop.region: ; preds = %omp.par.region1
br label %omp_loop.preheader
-omp_loop.preheader: ; preds = %omp.par.region1
+omp_loop.preheader: ; preds = %omp.wsloop.region
store i64 0, ptr %p.lowerbound, align 4
- store i64 499, ptr %p.upperbound, align 4
+ store i64 2499, ptr %p.upperbound, align 4
store i64 1, ptr %p.stride, align 4
- %omp_global_thread_num10 = call i32 @__kmpc_global_thread_num(ptr @1)
- call void @__kmpc_for_static_init_8u(ptr @1, i32 %omp_global_thread_num10, i32 34, ptr %p.lastiter, ptr %p.lowerbound, ptr %p.upperbound, ptr %p.stride, i64 1, i64 0)
- %6 = load i64, ptr %p.lowerbound, align 4
- %7 = load i64, ptr %p.upperbound, align 4
- %8 = sub i64 %7, %6
- %9 = add i64 %8, 1
+ %omp_global_thread_num13 = call i32 @__kmpc_global_thread_num(ptr @1)
+ call void @__kmpc_for_static_init_8u(ptr @1, i32 %omp_global_thread_num13, i32 34, ptr %p.lastiter, ptr %p.lowerbound, ptr %p.upperbound, ptr %p.stride, i64 1, i64 0)
+ %5 = load i64, ptr %p.lowerbound, align 4
+ %6 = load i64, ptr %p.upperbound, align 4
+ %7 = sub i64 %6, %5
+ %8 = add i64 %7, 1
br label %omp_loop.header
omp_loop.header: ; preds = %omp_loop.inc, %omp_loop.preheader
@@ -693,95 +2178,118 @@ omp_loop.header: ; preds = %omp_loop.inc, %omp_
br label %omp_loop.cond
omp_loop.cond: ; preds = %omp_loop.header
- %omp_loop.cmp = icmp ult i64 %omp_loop.iv, %9
+ %omp_loop.cmp = icmp ult i64 %omp_loop.iv, %8
br i1 %omp_loop.cmp, label %omp_loop.body, label %omp_loop.exit
omp_loop.exit: ; preds = %omp_loop.cond
- call void @__kmpc_for_static_fini(ptr @1, i32 %omp_global_thread_num10)
- %omp_global_thread_num11 = call i32 @__kmpc_global_thread_num(ptr @1)
- call void @__kmpc_barrier(ptr @2, i32 %omp_global_thread_num11)
+ call void @__kmpc_for_static_fini(ptr @1, i32 %omp_global_thread_num13)
+ %omp_global_thread_num14 = call i32 @__kmpc_global_thread_num(ptr @1)
+ call void @__kmpc_barrier(ptr @2, i32 %omp_global_thread_num14)
br label %omp_loop.after
omp_loop.after: ; preds = %omp_loop.exit
+ br label %omp.region.cont3
+
+omp.region.cont3: ; preds = %omp_loop.after
br label %omp.region.cont
-omp.region.cont: ; preds = %omp_loop.after
+omp.region.cont: ; preds = %omp.region.cont3
br label %omp.par.pre_finalize
omp.par.pre_finalize: ; preds = %omp.region.cont
- br label %omp.par.outlined.exit.exitStub
+ br label %.fini
+
+.fini: ; preds = %omp.par.pre_finalize
+ br label %omp.par.exit.exitStub
omp_loop.body: ; preds = %omp_loop.cond
- %10 = add i64 %omp_loop.iv, %6
- %11 = mul i64 %10, 1
- %12 = add i64 %11, 500
- br label %omp.wsloop.region
+ %9 = add i64 %omp_loop.iv, %5
+ %10 = mul i64 %9, 1
+ %11 = add i64 %10, 0
+ br label %omp.loop_nest.region
-omp.wsloop.region: ; preds = %omp_loop.body
- br label %omp.wsloop.region4
+omp.loop_nest.region: ; preds = %omp_loop.body
+ %12 = call ptr @llvm.stacksave.p0()
+ br label %omp.loop_nest.region5
-omp.wsloop.region4: ; preds = %omp.wsloop.region8, %omp.wsloop.region
- %13 = phi i64 [ %20, %omp.wsloop.region8 ], [ 0, %omp.wsloop.region ]
- %14 = icmp slt i64 %13, 1000
- br i1 %14, label %omp.wsloop.region5, label %omp.wsloop.region9
+omp.loop_nest.region5: ; preds = %omp.loop_nest.region
+ br label %omp.loop_nest.region6
-omp.wsloop.region9: ; preds = %omp.wsloop.region4
- br label %omp.region.cont3
+omp.loop_nest.region6: ; preds = %omp.loop_nest.region10, %omp.loop_nest.region5
+ %13 = phi i64 [ %21, %omp.loop_nest.region10 ], [ 0, %omp.loop_nest.region5 ]
+ %14 = icmp slt i64 %13, 10000
+ br i1 %14, label %omp.loop_nest.region7, label %omp.loop_nest.region11
+
+omp.loop_nest.region11: ; preds = %omp.loop_nest.region6
+ call void @llvm.stackrestore.p0(ptr %12)
+ br label %omp.loop_nest.region12
-omp.region.cont3: ; preds = %omp.wsloop.region9
+omp.loop_nest.region12: ; preds = %omp.loop_nest.region11
+ br label %omp.region.cont4
+
+omp.region.cont4: ; preds = %omp.loop_nest.region12
br label %omp_loop.inc
-omp_loop.inc: ; preds = %omp.region.cont3
+omp_loop.inc: ; preds = %omp.region.cont4
%omp_loop.next = add nuw i64 %omp_loop.iv, 1
br label %omp_loop.header
-omp.wsloop.region5: ; preds = %omp.wsloop.region4
+omp.loop_nest.region7: ; preds = %omp.loop_nest.region6
%15 = extractvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } %2, 1
- %16 = add nuw nsw i64 0, %13
- %17 = getelementptr float, ptr %15, i64 %16
- store float 0.000000e+00, ptr %17, align 4
- br label %omp.wsloop.region6
-
-omp.wsloop.region6: ; preds = %omp.wsloop.region7, %omp.wsloop.region5
- %18 = phi i64 [ %40, %omp.wsloop.region7 ], [ 0, %omp.wsloop.region5 ]
- %19 = icmp slt i64 %18, 1000
- br i1 %19, label %omp.wsloop.region7, label %omp.wsloop.region8
-
-omp.wsloop.region8: ; preds = %omp.wsloop.region6
- %20 = add i64 %13, 1
- br label %omp.wsloop.region4
-
-omp.wsloop.region7: ; preds = %omp.wsloop.region6
- %21 = extractvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } %3, 1
- %22 = add nuw nsw i64 0, %18
- %23 = getelementptr float, ptr %21, i64 %22
- %24 = load float, ptr %23, align 4
- %25 = fmul float %4, %24
- %26 = extractvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } %5, 1
- %27 = mul nuw nsw i64 %18, 1000
- %28 = add nuw nsw i64 %27, %13
- %29 = getelementptr float, ptr %26, i64 %28
- %30 = load float, ptr %29, align 4
- %31 = fmul float %25, %30
- %32 = extractvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } %2, 1
- %33 = add nuw nsw i64 0, %13
- %34 = getelementptr float, ptr %32, i64 %33
- %35 = load float, ptr %34, align 4
- %36 = fadd float %35, %31
- %37 = extractvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } %2, 1
- %38 = add nuw nsw i64 0, %13
- %39 = getelementptr float, ptr %37, i64 %38
- store float %36, ptr %39, align 4
- %40 = add i64 %18, 1
- br label %omp.wsloop.region6
-
-omp.par.outlined.exit.exitStub: ; preds = %omp.par.pre_finalize
+ %16 = mul nuw nsw i64 %11, 10000
+ %17 = add nuw nsw i64 %16, %13
+ %18 = getelementptr inbounds nuw float, ptr %15, i64 %17
+ store float 0.000000e+00, ptr %18, align 4
+ br label %omp.loop_nest.region8
+
+omp.loop_nest.region8: ; preds = %omp.loop_nest.region9, %omp.loop_nest.region7
+ %19 = phi i64 [ %43, %omp.loop_nest.region9 ], [ 0, %omp.loop_nest.region7 ]
+ %20 = icmp slt i64 %19, 10000
+ br i1 %20, label %omp.loop_nest.region9, label %omp.loop_nest.region10
+
+omp.loop_nest.region10: ; preds = %omp.loop_nest.region8
+ %21 = add i64 %13, 1
+ br label %omp.loop_nest.region6
+
+omp.loop_nest.region9: ; preds = %omp.loop_nest.region8
+ %22 = extractvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } %3, 1
+ %23 = mul nuw nsw i64 %11, 10000
+ %24 = add nuw nsw i64 %23, %19
+ %25 = getelementptr inbounds nuw float, ptr %22, i64 %24
+ %26 = load float, ptr %25, align 4
+ %27 = fmul float %4, %26
+ %28 = mul nuw nsw i64 %19, 10000
+ %29 = add nuw nsw i64 %28, %13
+ %30 = getelementptr inbounds nuw float, ptr %loadgep_, i64 %29
+ %31 = load float, ptr %30, align 4
+ %32 = fmul float %27, %31
+ %33 = extractvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } %2, 1
+ %34 = mul nuw nsw i64 %11, 10000
+ %35 = add nuw nsw i64 %34, %13
+ %36 = getelementptr inbounds nuw float, ptr %33, i64 %35
+ %37 = load float, ptr %36, align 4
+ %38 = fadd float %37, %32
+ %39 = extractvalue { ptr, ptr, i64, [2 x i64], [2 x i64] } %2, 1
+ %40 = mul nuw nsw i64 %11, 10000
+ %41 = add nuw nsw i64 %40, %13
+ %42 = getelementptr inbounds nuw float, ptr %39, i64 %41
+ store float %38, ptr %42, align 4
+ %43 = add i64 %19, 1
+ br label %omp.loop_nest.region8
+
+omp.par.exit.exitStub: ; preds = %.fini
ret void
}
; Function Attrs: nounwind
declare i32 @__kmpc_global_thread_num(ptr) #0
+; Function Attrs: nocallback nofree nosync nounwind willreturn
+declare ptr @llvm.stacksave.p0() #1
+
+; Function Attrs: nocallback nofree nosync nounwind willreturn
+declare void @llvm.stackrestore.p0(ptr) #1
+
; Function Attrs: nounwind
declare void @__kmpc_for_static_init_8u(ptr, i32, i32, ptr, ptr, ptr, ptr, i64, i64) #0
@@ -789,16 +2297,20 @@ declare void @__kmpc_for_static_init_8u(ptr, i32, i32, ptr, ptr, ptr, ptr, i64,
declare void @__kmpc_for_static_fini(ptr, i32) #0
; Function Attrs: convergent nounwind
-declare void @__kmpc_barrier(ptr, i32) #1
+declare void @__kmpc_barrier(ptr, i32) #2
; Function Attrs: nounwind
-declare !callback !1 void @__kmpc_fork_call(ptr, i32, ptr, ...) #0
+declare !callback !4 void @__kmpc_fork_call(ptr, i32, ptr, ...) #0
attributes #0 = { nounwind }
-attributes #1 = { convergent nounwind }
+attributes #1 = { nocallback nofree nosync nounwind willreturn }
+attributes #2 = { convergent nounwind }
!llvm.module.flags = !{!0}
!0 = !{i32 2, !"Debug Info Version", i32 3}
-!1 = !{!2}
-!2 = !{i64 2, i64 -1, i64 -1, i1 true}
+!1 = !{i64 8}
+!2 = !{i64 4}
+!3 = !{i64 1}
+!4 = !{!5}
+!5 = !{i64 2, i64 -1, i64 -1, i1 true}
diff --git a/genirs/2mm.mlir b/genirs/2mm.mlir
index 3f3a690..dce851f 100644
--- a/genirs/2mm.mlir
+++ b/genirs/2mm.mlir
@@ -1,130 +1,614 @@
-module attributes {avial.target_devices = [#dlti.target_device_spec<"type" = "node", "arch" = "x86">, #dlti.target_device_spec<"type" = "node", "arch" = "x86">]} {
+module attributes {dhir.target_devices = [#dlti.target_device_spec<"type" = "node", "arch" = "x86_64", "cost" = 1.000000e+00 : f32, "node_id" = "node0", "gpu_count" = 0 : i32, "gpu_arch" = [], "gpu_id" = []>, #dlti.target_device_spec<"type" = "node", "arch" = "x86_64", "cost" = 1.000000e+00 : f32, "node_id" = "node1", "gpu_count" = 0 : i32, "gpu_arch" = [], "gpu_id" = []>, #dlti.target_device_spec<"type" = "node", "arch" = "x86_64", "cost" = 1.000000e+00 : f32, "node_id" = "node2", "gpu_count" = 0 : i32, "gpu_arch" = [], "gpu_id" = []>, #dlti.target_device_spec<"type" = "node", "arch" = "x86_64", "cost" = 1.000000e+00 : f32, "node_id" = "node3", "gpu_count" = 0 : i32, "gpu_arch" = [], "gpu_id" = []>]} {
+ llvm.func @MPI_Send(!llvm.ptr, i32, i32, i32, i32, i32) -> i32
+ llvm.func @MPI_Recv(!llvm.ptr, i32, i32, i32, i32, i32, !llvm.ptr) -> i32
llvm.func @MPI_Barrier(i32) -> i32
- llvm.func @MPI_Comm_size(i32, !llvm.ptr) -> i32
llvm.func @MPI_Comm_rank(i32, !llvm.ptr) -> i32
llvm.func @MPI_Init(!llvm.ptr, !llvm.ptr) -> i32
- llvm.func @testFunc(%arg0: i32, %arg1: i32, %arg2: i32, %arg3: i32, %arg4: f32, %arg5: f32, %arg6: !llvm.ptr, %arg7: !llvm.ptr, %arg8: i64, %arg9: i64, %arg10: i64, %arg11: i64, %arg12: i64, %arg13: !llvm.ptr, %arg14: !llvm.ptr, %arg15: i64, %arg16: i64, %arg17: i64, %arg18: i64, %arg19: i64, %arg20: !llvm.ptr, %arg21: !llvm.ptr, %arg22: i64, %arg23: i64, %arg24: i64, %arg25: i64, %arg26: i64, %arg27: !llvm.ptr, %arg28: !llvm.ptr, %arg29: i64, %arg30: i64, %arg31: i64, %arg32: i64, %arg33: i64, %arg34: !llvm.ptr, %arg35: !llvm.ptr, %arg36: i64, %arg37: i64, %arg38: i64, %arg39: i64, %arg40: i64) {
- %0 = llvm.mlir.poison : !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)>
- %1 = llvm.insertvalue %arg34, %0[0] : !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)>
- %2 = llvm.insertvalue %arg35, %1[1] : !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)>
- %3 = llvm.insertvalue %arg36, %2[2] : !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)>
- %4 = llvm.insertvalue %arg37, %3[3, 0] : !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)>
- %5 = llvm.insertvalue %arg39, %4[4, 0] : !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)>
- %6 = llvm.insertvalue %arg38, %5[3, 1] : !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)>
- %7 = llvm.insertvalue %arg40, %6[4, 1] : !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)>
- %8 = llvm.mlir.poison : !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)>
- %9 = llvm.insertvalue %arg27, %8[0] : !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)>
- %10 = llvm.insertvalue %arg28, %9[1] : !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)>
- %11 = llvm.insertvalue %arg29, %10[2] : !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)>
- %12 = llvm.insertvalue %arg30, %11[3, 0] : !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)>
- %13 = llvm.insertvalue %arg32, %12[4, 0] : !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)>
- %14 = llvm.insertvalue %arg31, %13[3, 1] : !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)>
- %15 = llvm.insertvalue %arg33, %14[4, 1] : !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)>
- %16 = llvm.mlir.poison : !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)>
- %17 = llvm.insertvalue %arg20, %16[0] : !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)>
- %18 = llvm.insertvalue %arg21, %17[1] : !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)>
- %19 = llvm.insertvalue %arg22, %18[2] : !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)>
- %20 = llvm.insertvalue %arg23, %19[3, 0] : !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)>
- %21 = llvm.insertvalue %arg25, %20[4, 0] : !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)>
- %22 = llvm.insertvalue %arg24, %21[3, 1] : !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)>
- %23 = llvm.insertvalue %arg26, %22[4, 1] : !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)>
- %24 = llvm.mlir.poison : !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)>
- %25 = llvm.insertvalue %arg13, %24[0] : !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)>
- %26 = llvm.insertvalue %arg14, %25[1] : !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)>
- %27 = llvm.insertvalue %arg15, %26[2] : !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)>
- %28 = llvm.insertvalue %arg16, %27[3, 0] : !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)>
- %29 = llvm.insertvalue %arg18, %28[4, 0] : !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)>
- %30 = llvm.insertvalue %arg17, %29[3, 1] : !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)>
- %31 = llvm.insertvalue %arg19, %30[4, 1] : !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)>
- %32 = llvm.mlir.poison : !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)>
- %33 = llvm.insertvalue %arg6, %32[0] : !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)>
- %34 = llvm.insertvalue %arg7, %33[1] : !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)>
- %35 = llvm.insertvalue %arg8, %34[2] : !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)>
- %36 = llvm.insertvalue %arg9, %35[3, 0] : !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)>
- %37 = llvm.insertvalue %arg11, %36[4, 0] : !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)>
- %38 = llvm.insertvalue %arg10, %37[3, 1] : !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)>
- %39 = llvm.insertvalue %arg12, %38[4, 1] : !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)>
- %40 = llvm.mlir.zero : !llvm.ptr
- %41 = llvm.call @MPI_Init(%40, %40) : (!llvm.ptr, !llvm.ptr) -> i32
- %42 = llvm.mlir.constant(1140850688 : i64) : i64
- %43 = llvm.trunc %42 : i64 to i32
- %44 = llvm.mlir.constant(1 : i32) : i32
- %45 = llvm.alloca %44 x i32 : (i32) -> !llvm.ptr
- %46 = llvm.call @MPI_Comm_rank(%43, %45) : (i32, !llvm.ptr) -> i32
- %47 = llvm.load %45 : !llvm.ptr -> i32
- %48 = llvm.trunc %42 : i64 to i32
- %49 = llvm.mlir.constant(1 : i32) : i32
- %50 = llvm.alloca %49 x i32 : (i32) -> !llvm.ptr
- %51 = llvm.call @MPI_Comm_size(%48, %50) : (i32, !llvm.ptr) -> i32
- %52 = llvm.load %50 : !llvm.ptr -> i32
- %53 = llvm.mlir.constant(0.000000e+00 : f32) : f32
- %54 = llvm.mlir.constant(0 : i32) : i32
- %55 = llvm.srem %54, %52 : i32
- %56 = llvm.icmp "eq" %47, %55 : i32
- llvm.cond_br %56, ^bb1, ^bb2
+ llvm.func @malloc(i64) -> !llvm.ptr
+ llvm.func @buildRankNodeMaps(!llvm.ptr, !llvm.ptr, !llvm.ptr) attributes {sym_visibility = "private"}
+ llvm.mlir.global internal constant @arch_str_3("x86_64\00") {addr_space = 0 : i32}
+ llvm.mlir.global internal constant @node_str_3("node3\00") {addr_space = 0 : i32}
+ llvm.mlir.global internal constant @arch_str_2("x86_64\00") {addr_space = 0 : i32}
+ llvm.mlir.global internal constant @node_str_2("node2\00") {addr_space = 0 : i32}
+ llvm.mlir.global internal constant @arch_str_1("x86_64\00") {addr_space = 0 : i32}
+ llvm.mlir.global internal constant @node_str_1("node1\00") {addr_space = 0 : i32}
+ llvm.mlir.global internal constant @arch_str_0("x86_64\00") {addr_space = 0 : i32}
+ llvm.mlir.global internal constant @node_str_0("node0\00") {addr_space = 0 : i32}
+ llvm.func @kernel_2mm(%arg0: i32, %arg1: i32, %arg2: i32, %arg3: i32, %arg4: f32, %arg5: f32, %arg6: !llvm.ptr, %arg7: !llvm.ptr, %arg8: i64, %arg9: i64, %arg10: i64, %arg11: i64, %arg12: i64, %arg13: !llvm.ptr, %arg14: !llvm.ptr, %arg15: i64, %arg16: i64, %arg17: i64, %arg18: i64, %arg19: i64, %arg20: !llvm.ptr, %arg21: !llvm.ptr, %arg22: i64, %arg23: i64, %arg24: i64, %arg25: i64, %arg26: i64, %arg27: !llvm.ptr, %arg28: !llvm.ptr, %arg29: i64, %arg30: i64, %arg31: i64, %arg32: i64, %arg33: i64, %arg34: !llvm.ptr, %arg35: !llvm.ptr, %arg36: i64, %arg37: i64, %arg38: i64, %arg39: i64, %arg40: i64) {
+ %0 = llvm.mlir.zero : !llvm.ptr
+ %1 = llvm.mlir.constant(4 : i64) : i64
+ %2 = llvm.mlir.constant(1 : i64) : i64
+ %3 = llvm.mlir.addressof @node_str_0 : !llvm.ptr
+ %4 = llvm.mlir.addressof @arch_str_0 : !llvm.ptr
+ %5 = llvm.mlir.constant(1.000000e+00 : f32) : f32
+ %6 = llvm.mlir.addressof @node_str_1 : !llvm.ptr
+ %7 = llvm.mlir.addressof @arch_str_1 : !llvm.ptr
+ %8 = llvm.mlir.addressof @node_str_2 : !llvm.ptr
+ %9 = llvm.mlir.addressof @arch_str_2 : !llvm.ptr
+ %10 = llvm.mlir.addressof @node_str_3 : !llvm.ptr
+ %11 = llvm.mlir.addressof @arch_str_3 : !llvm.ptr
+ %12 = llvm.mlir.constant(4 : i32) : i32
+ %13 = llvm.mlir.constant(0.000000e+00 : f32) : f32
+ %14 = llvm.mlir.constant(0 : i32) : i32
+ %15 = llvm.mlir.constant(0 : index) : i64
+ %16 = llvm.mlir.constant(2500 : index) : i64
+ %17 = llvm.mlir.constant(1 : index) : i64
+ %18 = llvm.mlir.constant(10000 : index) : i64
+ %19 = llvm.mlir.constant(1 : i32) : i32
+ %20 = llvm.mlir.constant(2 : i32) : i32
+ %21 = llvm.mlir.constant(3 : i32) : i32
+ %22 = llvm.mlir.poison : !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)>
+ %23 = llvm.insertvalue %arg34, %22[0] : !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)>
+ %24 = llvm.insertvalue %arg35, %23[1] : !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)>
+ %25 = llvm.insertvalue %arg36, %24[2] : !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)>
+ %26 = llvm.insertvalue %arg37, %25[3, 0] : !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)>
+ %27 = llvm.insertvalue %arg39, %26[4, 0] : !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)>
+ %28 = llvm.insertvalue %arg38, %27[3, 1] : !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)>
+ %29 = llvm.insertvalue %arg40, %28[4, 1] : !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)>
+ %30 = llvm.insertvalue %arg13, %22[0] : !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)>
+ %31 = llvm.insertvalue %arg14, %30[1] : !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)>
+ %32 = llvm.insertvalue %arg15, %31[2] : !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)>
+ %33 = llvm.insertvalue %arg16, %32[3, 0] : !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)>
+ %34 = llvm.insertvalue %arg18, %33[4, 0] : !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)>
+ %35 = llvm.insertvalue %arg17, %34[3, 1] : !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)>
+ %36 = llvm.insertvalue %arg19, %35[4, 1] : !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)>
+ %37 = llvm.insertvalue %arg6, %22[0] : !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)>
+ %38 = llvm.insertvalue %arg7, %37[1] : !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)>
+ %39 = llvm.insertvalue %arg8, %38[2] : !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)>
+ %40 = llvm.insertvalue %arg9, %39[3, 0] : !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)>
+ %41 = llvm.insertvalue %arg11, %40[4, 0] : !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)>
+ %42 = llvm.insertvalue %arg10, %41[3, 1] : !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)>
+ %43 = llvm.insertvalue %arg12, %42[4, 1] : !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)>
+ %44 = llvm.mlir.zero : !llvm.ptr
+ %45 = llvm.call @MPI_Init(%44, %44) : (!llvm.ptr, !llvm.ptr) -> i32
+ %46 = llvm.mlir.constant(1140850688 : i64) : i64
+ %47 = llvm.trunc %46 : i64 to i32
+ %48 = llvm.mlir.constant(1 : i32) : i32
+ %49 = llvm.alloca %48 x i32 : (i32) -> !llvm.ptr
+ %50 = llvm.call @MPI_Comm_rank(%47, %49) : (i32, !llvm.ptr) -> i32
+ %51 = llvm.load %49 : !llvm.ptr -> i32
+ %52 = llvm.alloca %1 x !llvm.struct<(ptr, ptr, i32, f32)> : (i64) -> !llvm.ptr
+ %53 = llvm.getelementptr %52[0, 0] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(ptr, ptr, i32, f32)>
+ %54 = llvm.getelementptr %52[0, 1] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(ptr, ptr, i32, f32)>
+ %55 = llvm.getelementptr %52[0, 2] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(ptr, ptr, i32, f32)>
+ %56 = llvm.getelementptr %52[0, 3] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(ptr, ptr, i32, f32)>
+ llvm.store %3, %53 : !llvm.ptr, !llvm.ptr
+ llvm.store %4, %54 : !llvm.ptr, !llvm.ptr
+ llvm.store %14, %55 : i32, !llvm.ptr
+ llvm.store %5, %56 : f32, !llvm.ptr
+ %57 = llvm.getelementptr %52[1] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(ptr, ptr, i32, f32)>
+ %58 = llvm.getelementptr %57[0, 0] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(ptr, ptr, i32, f32)>
+ %59 = llvm.getelementptr %57[0, 1] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(ptr, ptr, i32, f32)>
+ %60 = llvm.getelementptr %57[0, 2] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(ptr, ptr, i32, f32)>
+ %61 = llvm.getelementptr %57[0, 3] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(ptr, ptr, i32, f32)>
+ llvm.store %6, %58 : !llvm.ptr, !llvm.ptr
+ llvm.store %7, %59 : !llvm.ptr, !llvm.ptr
+ llvm.store %14, %60 : i32, !llvm.ptr
+ llvm.store %5, %61 : f32, !llvm.ptr
+ %62 = llvm.getelementptr %52[2] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(ptr, ptr, i32, f32)>
+ %63 = llvm.getelementptr %62[0, 0] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(ptr, ptr, i32, f32)>
+ %64 = llvm.getelementptr %62[0, 1] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(ptr, ptr, i32, f32)>
+ %65 = llvm.getelementptr %62[0, 2] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(ptr, ptr, i32, f32)>
+ %66 = llvm.getelementptr %62[0, 3] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(ptr, ptr, i32, f32)>
+ llvm.store %8, %63 : !llvm.ptr, !llvm.ptr
+ llvm.store %9, %64 : !llvm.ptr, !llvm.ptr
+ llvm.store %14, %65 : i32, !llvm.ptr
+ llvm.store %5, %66 : f32, !llvm.ptr
+ %67 = llvm.getelementptr %52[3] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(ptr, ptr, i32, f32)>
+ %68 = llvm.getelementptr %67[0, 0] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(ptr, ptr, i32, f32)>
+ %69 = llvm.getelementptr %67[0, 1] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(ptr, ptr, i32, f32)>
+ %70 = llvm.getelementptr %67[0, 2] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(ptr, ptr, i32, f32)>
+ %71 = llvm.getelementptr %67[0, 3] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(ptr, ptr, i32, f32)>
+ llvm.store %10, %68 : !llvm.ptr, !llvm.ptr
+ llvm.store %11, %69 : !llvm.ptr, !llvm.ptr
+ llvm.store %14, %70 : i32, !llvm.ptr
+ llvm.store %5, %71 : f32, !llvm.ptr
+ %72 = llvm.alloca %2 x !llvm.struct<(i32, ptr)> : (i64) -> !llvm.ptr
+ %73 = llvm.getelementptr %72[0, 0] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(i32, ptr)>
+ %74 = llvm.getelementptr %72[0, 1] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(i32, ptr)>
+ llvm.store %12, %73 : i32, !llvm.ptr
+ llvm.store %52, %74 : !llvm.ptr, !llvm.ptr
+ %75 = llvm.getelementptr %0[4] : (!llvm.ptr) -> !llvm.ptr, i32
+ %76 = llvm.ptrtoint %75 : !llvm.ptr to i64
+ %77 = llvm.call @malloc(%76) : (i64) -> !llvm.ptr
+ %78 = llvm.getelementptr %0[4] : (!llvm.ptr) -> !llvm.ptr, i32
+ %79 = llvm.ptrtoint %78 : !llvm.ptr to i64
+ %80 = llvm.call @malloc(%79) : (i64) -> !llvm.ptr
+ %81 = llvm.ptrtoint %77 : !llvm.ptr to i64
+ %82 = llvm.ptrtoint %80 : !llvm.ptr to i64
+ %83 = llvm.inttoptr %81 : i64 to !llvm.ptr
+ %84 = llvm.inttoptr %82 : i64 to !llvm.ptr
+ llvm.call @buildRankNodeMaps(%72, %83, %84) : (!llvm.ptr, !llvm.ptr, !llvm.ptr) -> ()
+ %85 = llvm.sext %51 : i32 to i64
+ %86 = llvm.getelementptr inbounds|nuw %77[%85] : (!llvm.ptr, i64) -> !llvm.ptr, i32
+ %87 = llvm.load %86 : !llvm.ptr -> i32
+ %88 = llvm.extractvalue %36[0] : !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)>
+ %89 = llvm.extractvalue %36[1] : !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)>
+ %90 = llvm.mlir.poison : !llvm.struct<(ptr, ptr, i64)>
+ %91 = llvm.insertvalue %88, %90[0] : !llvm.struct<(ptr, ptr, i64)>
+ %92 = llvm.insertvalue %89, %91[1] : !llvm.struct<(ptr, ptr, i64)>
+ %93 = llvm.mlir.constant(0 : index) : i64
+ %94 = llvm.insertvalue %93, %92[2] : !llvm.struct<(ptr, ptr, i64)>
+ %95 = llvm.extractvalue %36[2] : !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)>
+ %96 = llvm.extractvalue %36[3, 0] : !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)>
+ %97 = llvm.extractvalue %36[3, 1] : !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)>
+ %98 = llvm.extractvalue %36[4, 0] : !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)>
+ %99 = llvm.extractvalue %36[4, 1] : !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)>
+ %100 = llvm.mlir.poison : !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)>
+ %101 = llvm.extractvalue %94[0] : !llvm.struct<(ptr, ptr, i64)>
+ %102 = llvm.extractvalue %94[1] : !llvm.struct<(ptr, ptr, i64)>
+ %103 = llvm.insertvalue %101, %100[0] : !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)>
+ %104 = llvm.insertvalue %102, %103[1] : !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)>
+ %105 = llvm.mlir.constant(0 : index) : i64
+ %106 = llvm.insertvalue %105, %104[2] : !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)>
+ %107 = llvm.mlir.constant(2500 : index) : i64
+ %108 = llvm.insertvalue %107, %106[3, 0] : !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)>
+ %109 = llvm.mlir.constant(10000 : index) : i64
+ %110 = llvm.insertvalue %109, %108[4, 0] : !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)>
+ %111 = llvm.mlir.constant(10000 : index) : i64
+ %112 = llvm.insertvalue %111, %110[3, 1] : !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)>
+ %113 = llvm.mlir.constant(1 : index) : i64
+ %114 = llvm.insertvalue %113, %112[4, 1] : !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)>
+ %115 = llvm.extractvalue %43[0] : !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)>
+ %116 = llvm.extractvalue %43[1] : !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)>
+ %117 = llvm.mlir.poison : !llvm.struct<(ptr, ptr, i64)>
+ %118 = llvm.insertvalue %115, %117[0] : !llvm.struct<(ptr, ptr, i64)>
+ %119 = llvm.insertvalue %116, %118[1] : !llvm.struct<(ptr, ptr, i64)>
+ %120 = llvm.mlir.constant(0 : index) : i64
+ %121 = llvm.insertvalue %120, %119[2] : !llvm.struct<(ptr, ptr, i64)>
+ %122 = llvm.extractvalue %43[2] : !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)>
+ %123 = llvm.extractvalue %43[3, 0] : !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)>
+ %124 = llvm.extractvalue %43[3, 1] : !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)>
+ %125 = llvm.extractvalue %43[4, 0] : !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)>
+ %126 = llvm.extractvalue %43[4, 1] : !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)>
+ %127 = llvm.mlir.poison : !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)>
+ %128 = llvm.extractvalue %121[0] : !llvm.struct<(ptr, ptr, i64)>
+ %129 = llvm.extractvalue %121[1] : !llvm.struct<(ptr, ptr, i64)>
+ %130 = llvm.insertvalue %128, %127[0] : !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)>
+ %131 = llvm.insertvalue %129, %130[1] : !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)>
+ %132 = llvm.mlir.constant(0 : index) : i64
+ %133 = llvm.insertvalue %132, %131[2] : !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)>
+ %134 = llvm.mlir.constant(2500 : index) : i64
+ %135 = llvm.insertvalue %134, %133[3, 0] : !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)>
+ %136 = llvm.mlir.constant(10000 : index) : i64
+ %137 = llvm.insertvalue %136, %135[4, 0] : !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)>
+ %138 = llvm.mlir.constant(10000 : index) : i64
+ %139 = llvm.insertvalue %138, %137[3, 1] : !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)>
+ %140 = llvm.mlir.constant(1 : index) : i64
+ %141 = llvm.insertvalue %140, %139[4, 1] : !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)>
+ %142 = llvm.extractvalue %36[0] : !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)>
+ %143 = llvm.extractvalue %36[1] : !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)>
+ %144 = llvm.mlir.poison : !llvm.struct<(ptr, ptr, i64)>
+ %145 = llvm.insertvalue %142, %144[0] : !llvm.struct<(ptr, ptr, i64)>
+ %146 = llvm.insertvalue %143, %145[1] : !llvm.struct<(ptr, ptr, i64)>
+ %147 = llvm.mlir.constant(0 : index) : i64
+ %148 = llvm.insertvalue %147, %146[2] : !llvm.struct<(ptr, ptr, i64)>
+ %149 = llvm.extractvalue %36[2] : !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)>
+ %150 = llvm.extractvalue %36[3, 0] : !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)>
+ %151 = llvm.extractvalue %36[3, 1] : !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)>
+ %152 = llvm.extractvalue %36[4, 0] : !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)>
+ %153 = llvm.extractvalue %36[4, 1] : !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)>
+ %154 = llvm.mlir.poison : !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)>
+ %155 = llvm.extractvalue %148[0] : !llvm.struct<(ptr, ptr, i64)>
+ %156 = llvm.extractvalue %148[1] : !llvm.struct<(ptr, ptr, i64)>
+ %157 = llvm.insertvalue %155, %154[0] : !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)>
+ %158 = llvm.insertvalue %156, %157[1] : !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)>
+ %159 = llvm.mlir.constant(25000000 : index) : i64
+ %160 = llvm.insertvalue %159, %158[2] : !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)>
+ %161 = llvm.mlir.constant(2500 : index) : i64
+ %162 = llvm.insertvalue %161, %160[3, 0] : !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)>
+ %163 = llvm.mlir.constant(10000 : index) : i64
+ %164 = llvm.insertvalue %163, %162[4, 0] : !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)>
+ %165 = llvm.mlir.constant(10000 : index) : i64
+ %166 = llvm.insertvalue %165, %164[3, 1] : !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)>
+ %167 = llvm.mlir.constant(1 : index) : i64
+ %168 = llvm.insertvalue %167, %166[4, 1] : !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)>
+ %169 = llvm.extractvalue %43[0] : !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)>
+ %170 = llvm.extractvalue %43[1] : !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)>
+ %171 = llvm.mlir.poison : !llvm.struct<(ptr, ptr, i64)>
+ %172 = llvm.insertvalue %169, %171[0] : !llvm.struct<(ptr, ptr, i64)>
+ %173 = llvm.insertvalue %170, %172[1] : !llvm.struct<(ptr, ptr, i64)>
+ %174 = llvm.mlir.constant(0 : index) : i64
+ %175 = llvm.insertvalue %174, %173[2] : !llvm.struct<(ptr, ptr, i64)>
+ %176 = llvm.extractvalue %43[2] : !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)>
+ %177 = llvm.extractvalue %43[3, 0] : !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)>
+ %178 = llvm.extractvalue %43[3, 1] : !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)>
+ %179 = llvm.extractvalue %43[4, 0] : !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)>
+ %180 = llvm.extractvalue %43[4, 1] : !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)>
+ %181 = llvm.mlir.poison : !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)>
+ %182 = llvm.extractvalue %175[0] : !llvm.struct<(ptr, ptr, i64)>
+ %183 = llvm.extractvalue %175[1] : !llvm.struct<(ptr, ptr, i64)>
+ %184 = llvm.insertvalue %182, %181[0] : !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)>
+ %185 = llvm.insertvalue %183, %184[1] : !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)>
+ %186 = llvm.mlir.constant(25000000 : index) : i64
+ %187 = llvm.insertvalue %186, %185[2] : !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)>
+ %188 = llvm.mlir.constant(2500 : index) : i64
+ %189 = llvm.insertvalue %188, %187[3, 0] : !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)>
+ %190 = llvm.mlir.constant(10000 : index) : i64
+ %191 = llvm.insertvalue %190, %189[4, 0] : !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)>
+ %192 = llvm.mlir.constant(10000 : index) : i64
+ %193 = llvm.insertvalue %192, %191[3, 1] : !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)>
+ %194 = llvm.mlir.constant(1 : index) : i64
+ %195 = llvm.insertvalue %194, %193[4, 1] : !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)>
+ %196 = llvm.extractvalue %36[0] : !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)>
+ %197 = llvm.extractvalue %36[1] : !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)>
+ %198 = llvm.mlir.poison : !llvm.struct<(ptr, ptr, i64)>
+ %199 = llvm.insertvalue %196, %198[0] : !llvm.struct<(ptr, ptr, i64)>
+ %200 = llvm.insertvalue %197, %199[1] : !llvm.struct<(ptr, ptr, i64)>
+ %201 = llvm.mlir.constant(0 : index) : i64
+ %202 = llvm.insertvalue %201, %200[2] : !llvm.struct<(ptr, ptr, i64)>
+ %203 = llvm.extractvalue %36[2] : !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)>
+ %204 = llvm.extractvalue %36[3, 0] : !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)>
+ %205 = llvm.extractvalue %36[3, 1] : !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)>
+ %206 = llvm.extractvalue %36[4, 0] : !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)>
+ %207 = llvm.extractvalue %36[4, 1] : !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)>
+ %208 = llvm.mlir.poison : !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)>
+ %209 = llvm.extractvalue %202[0] : !llvm.struct<(ptr, ptr, i64)>
+ %210 = llvm.extractvalue %202[1] : !llvm.struct<(ptr, ptr, i64)>
+ %211 = llvm.insertvalue %209, %208[0] : !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)>
+ %212 = llvm.insertvalue %210, %211[1] : !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)>
+ %213 = llvm.mlir.constant(50000000 : index) : i64
+ %214 = llvm.insertvalue %213, %212[2] : !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)>
+ %215 = llvm.mlir.constant(2500 : index) : i64
+ %216 = llvm.insertvalue %215, %214[3, 0] : !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)>
+ %217 = llvm.mlir.constant(10000 : index) : i64
+ %218 = llvm.insertvalue %217, %216[4, 0] : !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)>
+ %219 = llvm.mlir.constant(10000 : index) : i64
+ %220 = llvm.insertvalue %219, %218[3, 1] : !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)>
+ %221 = llvm.mlir.constant(1 : index) : i64
+ %222 = llvm.insertvalue %221, %220[4, 1] : !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)>
+ %223 = llvm.extractvalue %43[0] : !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)>
+ %224 = llvm.extractvalue %43[1] : !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)>
+ %225 = llvm.mlir.poison : !llvm.struct<(ptr, ptr, i64)>
+ %226 = llvm.insertvalue %223, %225[0] : !llvm.struct<(ptr, ptr, i64)>
+ %227 = llvm.insertvalue %224, %226[1] : !llvm.struct<(ptr, ptr, i64)>
+ %228 = llvm.mlir.constant(0 : index) : i64
+ %229 = llvm.insertvalue %228, %227[2] : !llvm.struct<(ptr, ptr, i64)>
+ %230 = llvm.extractvalue %43[2] : !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)>
+ %231 = llvm.extractvalue %43[3, 0] : !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)>
+ %232 = llvm.extractvalue %43[3, 1] : !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)>
+ %233 = llvm.extractvalue %43[4, 0] : !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)>
+ %234 = llvm.extractvalue %43[4, 1] : !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)>
+ %235 = llvm.mlir.poison : !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)>
+ %236 = llvm.extractvalue %229[0] : !llvm.struct<(ptr, ptr, i64)>
+ %237 = llvm.extractvalue %229[1] : !llvm.struct<(ptr, ptr, i64)>
+ %238 = llvm.insertvalue %236, %235[0] : !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)>
+ %239 = llvm.insertvalue %237, %238[1] : !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)>
+ %240 = llvm.mlir.constant(50000000 : index) : i64
+ %241 = llvm.insertvalue %240, %239[2] : !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)>
+ %242 = llvm.mlir.constant(2500 : index) : i64
+ %243 = llvm.insertvalue %242, %241[3, 0] : !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)>
+ %244 = llvm.mlir.constant(10000 : index) : i64
+ %245 = llvm.insertvalue %244, %243[4, 0] : !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)>
+ %246 = llvm.mlir.constant(10000 : index) : i64
+ %247 = llvm.insertvalue %246, %245[3, 1] : !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)>
+ %248 = llvm.mlir.constant(1 : index) : i64
+ %249 = llvm.insertvalue %248, %247[4, 1] : !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)>
+ %250 = llvm.extractvalue %36[0] : !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)>
+ %251 = llvm.extractvalue %36[1] : !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)>
+ %252 = llvm.mlir.poison : !llvm.struct<(ptr, ptr, i64)>
+ %253 = llvm.insertvalue %250, %252[0] : !llvm.struct<(ptr, ptr, i64)>
+ %254 = llvm.insertvalue %251, %253[1] : !llvm.struct<(ptr, ptr, i64)>
+ %255 = llvm.mlir.constant(0 : index) : i64
+ %256 = llvm.insertvalue %255, %254[2] : !llvm.struct<(ptr, ptr, i64)>
+ %257 = llvm.extractvalue %36[2] : !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)>
+ %258 = llvm.extractvalue %36[3, 0] : !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)>
+ %259 = llvm.extractvalue %36[3, 1] : !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)>
+ %260 = llvm.extractvalue %36[4, 0] : !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)>
+ %261 = llvm.extractvalue %36[4, 1] : !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)>
+ %262 = llvm.mlir.poison : !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)>
+ %263 = llvm.extractvalue %256[0] : !llvm.struct<(ptr, ptr, i64)>
+ %264 = llvm.extractvalue %256[1] : !llvm.struct<(ptr, ptr, i64)>
+ %265 = llvm.insertvalue %263, %262[0] : !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)>
+ %266 = llvm.insertvalue %264, %265[1] : !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)>
+ %267 = llvm.mlir.constant(75000000 : index) : i64
+ %268 = llvm.insertvalue %267, %266[2] : !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)>
+ %269 = llvm.mlir.constant(2500 : index) : i64
+ %270 = llvm.insertvalue %269, %268[3, 0] : !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)>
+ %271 = llvm.mlir.constant(10000 : index) : i64
+ %272 = llvm.insertvalue %271, %270[4, 0] : !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)>
+ %273 = llvm.mlir.constant(10000 : index) : i64
+ %274 = llvm.insertvalue %273, %272[3, 1] : !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)>
+ %275 = llvm.mlir.constant(1 : index) : i64
+ %276 = llvm.insertvalue %275, %274[4, 1] : !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)>
+ %277 = llvm.extractvalue %43[0] : !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)>
+ %278 = llvm.extractvalue %43[1] : !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)>
+ %279 = llvm.mlir.poison : !llvm.struct<(ptr, ptr, i64)>
+ %280 = llvm.insertvalue %277, %279[0] : !llvm.struct<(ptr, ptr, i64)>
+ %281 = llvm.insertvalue %278, %280[1] : !llvm.struct<(ptr, ptr, i64)>
+ %282 = llvm.mlir.constant(0 : index) : i64
+ %283 = llvm.insertvalue %282, %281[2] : !llvm.struct<(ptr, ptr, i64)>
+ %284 = llvm.extractvalue %43[2] : !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)>
+ %285 = llvm.extractvalue %43[3, 0] : !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)>
+ %286 = llvm.extractvalue %43[3, 1] : !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)>
+ %287 = llvm.extractvalue %43[4, 0] : !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)>
+ %288 = llvm.extractvalue %43[4, 1] : !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)>
+ %289 = llvm.mlir.poison : !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)>
+ %290 = llvm.extractvalue %283[0] : !llvm.struct<(ptr, ptr, i64)>
+ %291 = llvm.extractvalue %283[1] : !llvm.struct<(ptr, ptr, i64)>
+ %292 = llvm.insertvalue %290, %289[0] : !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)>
+ %293 = llvm.insertvalue %291, %292[1] : !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)>
+ %294 = llvm.mlir.constant(75000000 : index) : i64
+ %295 = llvm.insertvalue %294, %293[2] : !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)>
+ %296 = llvm.mlir.constant(2500 : index) : i64
+ %297 = llvm.insertvalue %296, %295[3, 0] : !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)>
+ %298 = llvm.mlir.constant(10000 : index) : i64
+ %299 = llvm.insertvalue %298, %297[4, 0] : !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)>
+ %300 = llvm.mlir.constant(10000 : index) : i64
+ %301 = llvm.insertvalue %300, %299[3, 1] : !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)>
+ %302 = llvm.mlir.constant(1 : index) : i64
+ %303 = llvm.insertvalue %302, %301[4, 1] : !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)>
+ %304 = llvm.extractvalue %43[0] : !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)>
+ %305 = llvm.extractvalue %43[1] : !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)>
+ %306 = llvm.mlir.poison : !llvm.struct<(ptr, ptr, i64)>
+ %307 = llvm.insertvalue %304, %306[0] : !llvm.struct<(ptr, ptr, i64)>
+ %308 = llvm.insertvalue %305, %307[1] : !llvm.struct<(ptr, ptr, i64)>
+ %309 = llvm.mlir.constant(0 : index) : i64
+ %310 = llvm.insertvalue %309, %308[2] : !llvm.struct<(ptr, ptr, i64)>
+ %311 = llvm.extractvalue %43[2] : !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)>
+ %312 = llvm.extractvalue %43[3, 0] : !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)>
+ %313 = llvm.extractvalue %43[3, 1] : !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)>
+ %314 = llvm.extractvalue %43[4, 0] : !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)>
+ %315 = llvm.extractvalue %43[4, 1] : !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)>
+ %316 = llvm.mlir.poison : !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)>
+ %317 = llvm.extractvalue %310[0] : !llvm.struct<(ptr, ptr, i64)>
+ %318 = llvm.extractvalue %310[1] : !llvm.struct<(ptr, ptr, i64)>
+ %319 = llvm.insertvalue %317, %316[0] : !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)>
+ %320 = llvm.insertvalue %318, %319[1] : !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)>
+ %321 = llvm.mlir.constant(0 : index) : i64
+ %322 = llvm.insertvalue %321, %320[2] : !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)>
+ %323 = llvm.mlir.constant(2500 : index) : i64
+ %324 = llvm.insertvalue %323, %322[3, 0] : !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)>
+ %325 = llvm.mlir.constant(10000 : index) : i64
+ %326 = llvm.insertvalue %325, %324[4, 0] : !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)>
+ %327 = llvm.mlir.constant(10000 : index) : i64
+ %328 = llvm.insertvalue %327, %326[3, 1] : !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)>
+ %329 = llvm.mlir.constant(1 : index) : i64
+ %330 = llvm.insertvalue %329, %328[4, 1] : !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)>
+ %331 = llvm.extractvalue %29[0] : !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)>
+ %332 = llvm.extractvalue %29[1] : !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)>
+ %333 = llvm.mlir.poison : !llvm.struct<(ptr, ptr, i64)>
+ %334 = llvm.insertvalue %331, %333[0] : !llvm.struct<(ptr, ptr, i64)>
+ %335 = llvm.insertvalue %332, %334[1] : !llvm.struct<(ptr, ptr, i64)>
+ %336 = llvm.mlir.constant(0 : index) : i64
+ %337 = llvm.insertvalue %336, %335[2] : !llvm.struct<(ptr, ptr, i64)>
+ %338 = llvm.extractvalue %29[2] : !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)>
+ %339 = llvm.extractvalue %29[3, 0] : !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)>
+ %340 = llvm.extractvalue %29[3, 1] : !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)>
+ %341 = llvm.extractvalue %29[4, 0] : !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)>
+ %342 = llvm.extractvalue %29[4, 1] : !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)>
+ %343 = llvm.mlir.poison : !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)>
+ %344 = llvm.extractvalue %337[0] : !llvm.struct<(ptr, ptr, i64)>
+ %345 = llvm.extractvalue %337[1] : !llvm.struct<(ptr, ptr, i64)>
+ %346 = llvm.insertvalue %344, %343[0] : !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)>
+ %347 = llvm.insertvalue %345, %346[1] : !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)>
+ %348 = llvm.mlir.constant(0 : index) : i64
+ %349 = llvm.insertvalue %348, %347[2] : !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)>
+ %350 = llvm.mlir.constant(2500 : index) : i64
+ %351 = llvm.insertvalue %350, %349[3, 0] : !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)>
+ %352 = llvm.mlir.constant(10000 : index) : i64
+ %353 = llvm.insertvalue %352, %351[4, 0] : !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)>
+ %354 = llvm.mlir.constant(10000 : index) : i64
+ %355 = llvm.insertvalue %354, %353[3, 1] : !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)>
+ %356 = llvm.mlir.constant(1 : index) : i64
+ %357 = llvm.insertvalue %356, %355[4, 1] : !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)>
+ %358 = llvm.extractvalue %43[0] : !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)>
+ %359 = llvm.extractvalue %43[1] : !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)>
+ %360 = llvm.mlir.poison : !llvm.struct<(ptr, ptr, i64)>
+ %361 = llvm.insertvalue %358, %360[0] : !llvm.struct<(ptr, ptr, i64)>
+ %362 = llvm.insertvalue %359, %361[1] : !llvm.struct<(ptr, ptr, i64)>
+ %363 = llvm.mlir.constant(0 : index) : i64
+ %364 = llvm.insertvalue %363, %362[2] : !llvm.struct<(ptr, ptr, i64)>
+ %365 = llvm.extractvalue %43[2] : !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)>
+ %366 = llvm.extractvalue %43[3, 0] : !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)>
+ %367 = llvm.extractvalue %43[3, 1] : !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)>
+ %368 = llvm.extractvalue %43[4, 0] : !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)>
+ %369 = llvm.extractvalue %43[4, 1] : !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)>
+ %370 = llvm.mlir.poison : !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)>
+ %371 = llvm.extractvalue %364[0] : !llvm.struct<(ptr, ptr, i64)>
+ %372 = llvm.extractvalue %364[1] : !llvm.struct<(ptr, ptr, i64)>
+ %373 = llvm.insertvalue %371, %370[0] : !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)>
+ %374 = llvm.insertvalue %372, %373[1] : !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)>
+ %375 = llvm.mlir.constant(25000000 : index) : i64
+ %376 = llvm.insertvalue %375, %374[2] : !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)>
+ %377 = llvm.mlir.constant(2500 : index) : i64
+ %378 = llvm.insertvalue %377, %376[3, 0] : !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)>
+ %379 = llvm.mlir.constant(10000 : index) : i64
+ %380 = llvm.insertvalue %379, %378[4, 0] : !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)>
+ %381 = llvm.mlir.constant(10000 : index) : i64
+ %382 = llvm.insertvalue %381, %380[3, 1] : !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)>
+ %383 = llvm.mlir.constant(1 : index) : i64
+ %384 = llvm.insertvalue %383, %382[4, 1] : !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)>
+ %385 = llvm.extractvalue %29[0] : !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)>
+ %386 = llvm.extractvalue %29[1] : !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)>
+ %387 = llvm.mlir.poison : !llvm.struct<(ptr, ptr, i64)>
+ %388 = llvm.insertvalue %385, %387[0] : !llvm.struct<(ptr, ptr, i64)>
+ %389 = llvm.insertvalue %386, %388[1] : !llvm.struct<(ptr, ptr, i64)>
+ %390 = llvm.mlir.constant(0 : index) : i64
+ %391 = llvm.insertvalue %390, %389[2] : !llvm.struct<(ptr, ptr, i64)>
+ %392 = llvm.extractvalue %29[2] : !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)>
+ %393 = llvm.extractvalue %29[3, 0] : !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)>
+ %394 = llvm.extractvalue %29[3, 1] : !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)>
+ %395 = llvm.extractvalue %29[4, 0] : !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)>
+ %396 = llvm.extractvalue %29[4, 1] : !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)>
+ %397 = llvm.mlir.poison : !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)>
+ %398 = llvm.extractvalue %391[0] : !llvm.struct<(ptr, ptr, i64)>
+ %399 = llvm.extractvalue %391[1] : !llvm.struct<(ptr, ptr, i64)>
+ %400 = llvm.insertvalue %398, %397[0] : !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)>
+ %401 = llvm.insertvalue %399, %400[1] : !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)>
+ %402 = llvm.mlir.constant(25000000 : index) : i64
+ %403 = llvm.insertvalue %402, %401[2] : !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)>
+ %404 = llvm.mlir.constant(2500 : index) : i64
+ %405 = llvm.insertvalue %404, %403[3, 0] : !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)>
+ %406 = llvm.mlir.constant(10000 : index) : i64
+ %407 = llvm.insertvalue %406, %405[4, 0] : !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)>
+ %408 = llvm.mlir.constant(10000 : index) : i64
+ %409 = llvm.insertvalue %408, %407[3, 1] : !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)>
+ %410 = llvm.mlir.constant(1 : index) : i64
+ %411 = llvm.insertvalue %410, %409[4, 1] : !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)>
+ %412 = llvm.extractvalue %43[0] : !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)>
+ %413 = llvm.extractvalue %43[1] : !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)>
+ %414 = llvm.mlir.poison : !llvm.struct<(ptr, ptr, i64)>
+ %415 = llvm.insertvalue %412, %414[0] : !llvm.struct<(ptr, ptr, i64)>
+ %416 = llvm.insertvalue %413, %415[1] : !llvm.struct<(ptr, ptr, i64)>
+ %417 = llvm.mlir.constant(0 : index) : i64
+ %418 = llvm.insertvalue %417, %416[2] : !llvm.struct<(ptr, ptr, i64)>
+ %419 = llvm.extractvalue %43[2] : !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)>
+ %420 = llvm.extractvalue %43[3, 0] : !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)>
+ %421 = llvm.extractvalue %43[3, 1] : !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)>
+ %422 = llvm.extractvalue %43[4, 0] : !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)>
+ %423 = llvm.extractvalue %43[4, 1] : !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)>
+ %424 = llvm.mlir.poison : !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)>
+ %425 = llvm.extractvalue %418[0] : !llvm.struct<(ptr, ptr, i64)>
+ %426 = llvm.extractvalue %418[1] : !llvm.struct<(ptr, ptr, i64)>
+ %427 = llvm.insertvalue %425, %424[0] : !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)>
+ %428 = llvm.insertvalue %426, %427[1] : !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)>
+ %429 = llvm.mlir.constant(50000000 : index) : i64
+ %430 = llvm.insertvalue %429, %428[2] : !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)>
+ %431 = llvm.mlir.constant(2500 : index) : i64
+ %432 = llvm.insertvalue %431, %430[3, 0] : !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)>
+ %433 = llvm.mlir.constant(10000 : index) : i64
+ %434 = llvm.insertvalue %433, %432[4, 0] : !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)>
+ %435 = llvm.mlir.constant(10000 : index) : i64
+ %436 = llvm.insertvalue %435, %434[3, 1] : !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)>
+ %437 = llvm.mlir.constant(1 : index) : i64
+ %438 = llvm.insertvalue %437, %436[4, 1] : !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)>
+ %439 = llvm.extractvalue %29[0] : !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)>
+ %440 = llvm.extractvalue %29[1] : !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)>
+ %441 = llvm.mlir.poison : !llvm.struct<(ptr, ptr, i64)>
+ %442 = llvm.insertvalue %439, %441[0] : !llvm.struct<(ptr, ptr, i64)>
+ %443 = llvm.insertvalue %440, %442[1] : !llvm.struct<(ptr, ptr, i64)>
+ %444 = llvm.mlir.constant(0 : index) : i64
+ %445 = llvm.insertvalue %444, %443[2] : !llvm.struct<(ptr, ptr, i64)>
+ %446 = llvm.extractvalue %29[2] : !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)>
+ %447 = llvm.extractvalue %29[3, 0] : !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)>
+ %448 = llvm.extractvalue %29[3, 1] : !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)>
+ %449 = llvm.extractvalue %29[4, 0] : !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)>
+ %450 = llvm.extractvalue %29[4, 1] : !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)>
+ %451 = llvm.mlir.poison : !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)>
+ %452 = llvm.extractvalue %445[0] : !llvm.struct<(ptr, ptr, i64)>
+ %453 = llvm.extractvalue %445[1] : !llvm.struct<(ptr, ptr, i64)>
+ %454 = llvm.insertvalue %452, %451[0] : !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)>
+ %455 = llvm.insertvalue %453, %454[1] : !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)>
+ %456 = llvm.mlir.constant(50000000 : index) : i64
+ %457 = llvm.insertvalue %456, %455[2] : !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)>
+ %458 = llvm.mlir.constant(2500 : index) : i64
+ %459 = llvm.insertvalue %458, %457[3, 0] : !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)>
+ %460 = llvm.mlir.constant(10000 : index) : i64
+ %461 = llvm.insertvalue %460, %459[4, 0] : !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)>
+ %462 = llvm.mlir.constant(10000 : index) : i64
+ %463 = llvm.insertvalue %462, %461[3, 1] : !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)>
+ %464 = llvm.mlir.constant(1 : index) : i64
+ %465 = llvm.insertvalue %464, %463[4, 1] : !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)>
+ %466 = llvm.extractvalue %43[0] : !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)>
+ %467 = llvm.extractvalue %43[1] : !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)>
+ %468 = llvm.mlir.poison : !llvm.struct<(ptr, ptr, i64)>
+ %469 = llvm.insertvalue %466, %468[0] : !llvm.struct<(ptr, ptr, i64)>
+ %470 = llvm.insertvalue %467, %469[1] : !llvm.struct<(ptr, ptr, i64)>
+ %471 = llvm.mlir.constant(0 : index) : i64
+ %472 = llvm.insertvalue %471, %470[2] : !llvm.struct<(ptr, ptr, i64)>
+ %473 = llvm.extractvalue %43[2] : !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)>
+ %474 = llvm.extractvalue %43[3, 0] : !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)>
+ %475 = llvm.extractvalue %43[3, 1] : !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)>
+ %476 = llvm.extractvalue %43[4, 0] : !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)>
+ %477 = llvm.extractvalue %43[4, 1] : !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)>
+ %478 = llvm.mlir.poison : !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)>
+ %479 = llvm.extractvalue %472[0] : !llvm.struct<(ptr, ptr, i64)>
+ %480 = llvm.extractvalue %472[1] : !llvm.struct<(ptr, ptr, i64)>
+ %481 = llvm.insertvalue %479, %478[0] : !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)>
+ %482 = llvm.insertvalue %480, %481[1] : !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)>
+ %483 = llvm.mlir.constant(75000000 : index) : i64
+ %484 = llvm.insertvalue %483, %482[2] : !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)>
+ %485 = llvm.mlir.constant(2500 : index) : i64
+ %486 = llvm.insertvalue %485, %484[3, 0] : !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)>
+ %487 = llvm.mlir.constant(10000 : index) : i64
+ %488 = llvm.insertvalue %487, %486[4, 0] : !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)>
+ %489 = llvm.mlir.constant(10000 : index) : i64
+ %490 = llvm.insertvalue %489, %488[3, 1] : !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)>
+ %491 = llvm.mlir.constant(1 : index) : i64
+ %492 = llvm.insertvalue %491, %490[4, 1] : !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)>
+ %493 = llvm.extractvalue %29[0] : !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)>
+ %494 = llvm.extractvalue %29[1] : !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)>
+ %495 = llvm.mlir.poison : !llvm.struct<(ptr, ptr, i64)>
+ %496 = llvm.insertvalue %493, %495[0] : !llvm.struct<(ptr, ptr, i64)>
+ %497 = llvm.insertvalue %494, %496[1] : !llvm.struct<(ptr, ptr, i64)>
+ %498 = llvm.mlir.constant(0 : index) : i64
+ %499 = llvm.insertvalue %498, %497[2] : !llvm.struct<(ptr, ptr, i64)>
+ %500 = llvm.extractvalue %29[2] : !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)>
+ %501 = llvm.extractvalue %29[3, 0] : !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)>
+ %502 = llvm.extractvalue %29[3, 1] : !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)>
+ %503 = llvm.extractvalue %29[4, 0] : !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)>
+ %504 = llvm.extractvalue %29[4, 1] : !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)>
+ %505 = llvm.mlir.poison : !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)>
+ %506 = llvm.extractvalue %499[0] : !llvm.struct<(ptr, ptr, i64)>
+ %507 = llvm.extractvalue %499[1] : !llvm.struct<(ptr, ptr, i64)>
+ %508 = llvm.insertvalue %506, %505[0] : !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)>
+ %509 = llvm.insertvalue %507, %508[1] : !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)>
+ %510 = llvm.mlir.constant(75000000 : index) : i64
+ %511 = llvm.insertvalue %510, %509[2] : !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)>
+ %512 = llvm.mlir.constant(2500 : index) : i64
+ %513 = llvm.insertvalue %512, %511[3, 0] : !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)>
+ %514 = llvm.mlir.constant(10000 : index) : i64
+ %515 = llvm.insertvalue %514, %513[4, 0] : !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)>
+ %516 = llvm.mlir.constant(10000 : index) : i64
+ %517 = llvm.insertvalue %516, %515[3, 1] : !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)>
+ %518 = llvm.mlir.constant(1 : index) : i64
+ %519 = llvm.insertvalue %518, %517[4, 1] : !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)>
+ %520 = llvm.icmp "eq" %87, %14 : i32
+ llvm.cond_br %520, ^bb1, ^bb2
^bb1: // pred: ^bb0
- %57 = llvm.mlir.constant(500 : index) : i64
- %58 = llvm.mlir.constant(1000 : index) : i64
- %59 = llvm.mlir.constant(1 : index) : i64
omp.parallel {
omp.wsloop {
- omp.loop_nest (%arg41) : i64 = (%57) to (%58) step (%59) {
- %80 = llvm.mlir.constant(0 : index) : i64
- %81 = llvm.mlir.constant(0 : index) : i64
- %82 = llvm.mlir.constant(1000 : index) : i64
- %83 = llvm.mlir.constant(1 : index) : i64
- llvm.br ^bb1(%81 : i64)
- ^bb1(%84: i64): // 2 preds: ^bb0, ^bb5
- %85 = llvm.icmp "slt" %84, %82 : i64
- llvm.cond_br %85, ^bb2, ^bb6
- ^bb2: // pred: ^bb1
- %86 = llvm.extractvalue %39[1] : !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)>
- %87 = llvm.mlir.constant(1000 : index) : i64
- %88 = llvm.mul %80, %87 overflow : i64
- %89 = llvm.add %88, %84 overflow : i64
- %90 = llvm.getelementptr %86[%89] : (!llvm.ptr, i64) -> !llvm.ptr, f32
- llvm.store %53, %90 : f32, !llvm.ptr
- %91 = llvm.mlir.constant(0 : index) : i64
- %92 = llvm.mlir.constant(1000 : index) : i64
- %93 = llvm.mlir.constant(1 : index) : i64
- llvm.br ^bb3(%91 : i64)
- ^bb3(%94: i64): // 2 preds: ^bb2, ^bb4
- %95 = llvm.icmp "slt" %94, %92 : i64
- llvm.cond_br %95, ^bb4, ^bb5
- ^bb4: // pred: ^bb3
- %96 = llvm.extractvalue %31[1] : !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)>
- %97 = llvm.mlir.constant(1000 : index) : i64
- %98 = llvm.mul %80, %97 overflow : i64
- %99 = llvm.add %98, %94 overflow : i64
- %100 = llvm.getelementptr %96[%99] : (!llvm.ptr, i64) -> !llvm.ptr, f32
- %101 = llvm.load %100 : !llvm.ptr -> f32
- %102 = llvm.fmul %arg4, %101 : f32
- %103 = llvm.extractvalue %23[1] : !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)>
- %104 = llvm.mlir.constant(1000 : index) : i64
- %105 = llvm.mul %94, %104 overflow : i64
- %106 = llvm.add %105, %84 overflow : i64
- %107 = llvm.getelementptr %103[%106] : (!llvm.ptr, i64) -> !llvm.ptr, f32
- %108 = llvm.load %107 : !llvm.ptr -> f32
- %109 = llvm.fmul %102, %108 : f32
- %110 = llvm.extractvalue %39[1] : !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)>
- %111 = llvm.mlir.constant(1000 : index) : i64
- %112 = llvm.mul %80, %111 overflow : i64
- %113 = llvm.add %112, %84 overflow : i64
- %114 = llvm.getelementptr %110[%113] : (!llvm.ptr, i64) -> !llvm.ptr, f32
- %115 = llvm.load %114 : !llvm.ptr -> f32
- %116 = llvm.fadd %115, %109 : f32
- %117 = llvm.extractvalue %39[1] : !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)>
- %118 = llvm.mlir.constant(1000 : index) : i64
- %119 = llvm.mul %80, %118 overflow : i64
- %120 = llvm.add %119, %84 overflow : i64
- %121 = llvm.getelementptr %117[%120] : (!llvm.ptr, i64) -> !llvm.ptr, f32
- llvm.store %116, %121 : f32, !llvm.ptr
- %122 = llvm.add %94, %93 : i64
- llvm.br ^bb3(%122 : i64)
- ^bb5: // pred: ^bb3
- %123 = llvm.add %84, %83 : i64
- llvm.br ^bb1(%123 : i64)
- ^bb6: // pred: ^bb1
+ omp.loop_nest (%arg41) : i64 = (%15) to (%16) step (%17) {
+ %834 = llvm.intr.stacksave : !llvm.ptr
+ llvm.br ^bb1
+ ^bb1: // pred: ^bb0
+ llvm.br ^bb2(%15 : i64)
+ ^bb2(%835: i64): // 2 preds: ^bb1, ^bb6
+ %836 = llvm.icmp "slt" %835, %18 : i64
+ llvm.cond_br %836, ^bb3, ^bb7
+ ^bb3: // pred: ^bb2
+ %837 = llvm.extractvalue %141[1] : !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)>
+ %838 = llvm.mul %arg41, %18 overflow : i64
+ %839 = llvm.add %838, %835 overflow : i64
+ %840 = llvm.getelementptr inbounds|nuw %837[%839] : (!llvm.ptr, i64) -> !llvm.ptr, f32
+ llvm.store %13, %840 : f32, !llvm.ptr
+ llvm.br ^bb4(%15 : i64)
+ ^bb4(%841: i64): // 2 preds: ^bb3, ^bb5
+ %842 = llvm.icmp "slt" %841, %18 : i64
+ llvm.cond_br %842, ^bb5, ^bb6
+ ^bb5: // pred: ^bb4
+ %843 = llvm.extractvalue %114[1] : !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)>
+ %844 = llvm.mul %arg41, %18 overflow : i64
+ %845 = llvm.add %844, %841 overflow : i64
+ %846 = llvm.getelementptr inbounds|nuw %843[%845] : (!llvm.ptr, i64) -> !llvm.ptr, f32
+ %847 = llvm.load %846 : !llvm.ptr -> f32
+ %848 = llvm.fmul %arg4, %847 : f32
+ %849 = llvm.mul %841, %18 overflow : i64
+ %850 = llvm.add %849, %835 overflow : i64
+ %851 = llvm.getelementptr inbounds|nuw %arg21[%850] : (!llvm.ptr, i64) -> !llvm.ptr, f32
+ %852 = llvm.load %851 : !llvm.ptr -> f32
+ %853 = llvm.fmul %848, %852 : f32
+ %854 = llvm.extractvalue %141[1] : !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)>
+ %855 = llvm.mul %arg41, %18 overflow : i64
+ %856 = llvm.add %855, %835 overflow : i64
+ %857 = llvm.getelementptr inbounds|nuw %854[%856] : (!llvm.ptr, i64) -> !llvm.ptr, f32
+ %858 = llvm.load %857 : !llvm.ptr -> f32
+ %859 = llvm.fadd %858, %853 : f32
+ %860 = llvm.extractvalue %141[1] : !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)>
+ %861 = llvm.mul %arg41, %18 overflow : i64
+ %862 = llvm.add %861, %835 overflow : i64
+ %863 = llvm.getelementptr inbounds|nuw %860[%862] : (!llvm.ptr, i64) -> !llvm.ptr, f32
+ llvm.store %859, %863 : f32, !llvm.ptr
+ %864 = llvm.add %841, %17 : i64
+ llvm.br ^bb4(%864 : i64)
+ ^bb6: // pred: ^bb4
+ %865 = llvm.add %835, %17 : i64
+ llvm.br ^bb2(%865 : i64)
+ ^bb7: // pred: ^bb2
+ llvm.intr.stackrestore %834 : !llvm.ptr
+ llvm.br ^bb8
+ ^bb8: // pred: ^bb7
omp.yield
}
}
@@ -132,73 +616,65 @@ module attributes {avial.target_devices = [#dlti.target_device_spec<"type" = "no
}
llvm.br ^bb2
^bb2: // 2 preds: ^bb0, ^bb1
- %60 = llvm.mlir.constant(1 : i32) : i32
- %61 = llvm.srem %60, %52 : i32
- %62 = llvm.icmp "eq" %47, %61 : i32
- llvm.cond_br %62, ^bb3, ^bb4
+ %521 = llvm.icmp "eq" %87, %19 : i32
+ llvm.cond_br %521, ^bb3, ^bb4
^bb3: // pred: ^bb2
- %63 = llvm.mlir.constant(0 : index) : i64
- %64 = llvm.mlir.constant(500 : index) : i64
- %65 = llvm.mlir.constant(1 : index) : i64
omp.parallel {
omp.wsloop {
- omp.loop_nest (%arg41) : i64 = (%63) to (%64) step (%65) {
- %80 = llvm.mlir.constant(0 : index) : i64
- %81 = llvm.mlir.constant(0 : index) : i64
- %82 = llvm.mlir.constant(1000 : index) : i64
- %83 = llvm.mlir.constant(1 : index) : i64
- llvm.br ^bb1(%81 : i64)
- ^bb1(%84: i64): // 2 preds: ^bb0, ^bb5
- %85 = llvm.icmp "slt" %84, %82 : i64
- llvm.cond_br %85, ^bb2, ^bb6
- ^bb2: // pred: ^bb1
- %86 = llvm.extractvalue %39[1] : !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)>
- %87 = llvm.mlir.constant(1000 : index) : i64
- %88 = llvm.mul %80, %87 overflow : i64
- %89 = llvm.add %88, %84 overflow : i64
- %90 = llvm.getelementptr %86[%89] : (!llvm.ptr, i64) -> !llvm.ptr, f32
- llvm.store %53, %90 : f32, !llvm.ptr
- %91 = llvm.mlir.constant(0 : index) : i64
- %92 = llvm.mlir.constant(1000 : index) : i64
- %93 = llvm.mlir.constant(1 : index) : i64
- llvm.br ^bb3(%91 : i64)
- ^bb3(%94: i64): // 2 preds: ^bb2, ^bb4
- %95 = llvm.icmp "slt" %94, %92 : i64
- llvm.cond_br %95, ^bb4, ^bb5
- ^bb4: // pred: ^bb3
- %96 = llvm.extractvalue %31[1] : !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)>
- %97 = llvm.mlir.constant(1000 : index) : i64
- %98 = llvm.mul %80, %97 overflow : i64
- %99 = llvm.add %98, %94 overflow : i64
- %100 = llvm.getelementptr %96[%99] : (!llvm.ptr, i64) -> !llvm.ptr, f32
- %101 = llvm.load %100 : !llvm.ptr -> f32
- %102 = llvm.fmul %arg4, %101 : f32
- %103 = llvm.extractvalue %23[1] : !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)>
- %104 = llvm.mlir.constant(1000 : index) : i64
- %105 = llvm.mul %94, %104 overflow : i64
- %106 = llvm.add %105, %84 overflow : i64
- %107 = llvm.getelementptr %103[%106] : (!llvm.ptr, i64) -> !llvm.ptr, f32
- %108 = llvm.load %107 : !llvm.ptr -> f32
- %109 = llvm.fmul %102, %108 : f32
- %110 = llvm.extractvalue %39[1] : !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)>
- %111 = llvm.mlir.constant(1000 : index) : i64
- %112 = llvm.mul %80, %111 overflow : i64
- %113 = llvm.add %112, %84 overflow : i64
- %114 = llvm.getelementptr %110[%113] : (!llvm.ptr, i64) -> !llvm.ptr, f32
- %115 = llvm.load %114 : !llvm.ptr -> f32
- %116 = llvm.fadd %115, %109 : f32
- %117 = llvm.extractvalue %39[1] : !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)>
- %118 = llvm.mlir.constant(1000 : index) : i64
- %119 = llvm.mul %80, %118 overflow : i64
- %120 = llvm.add %119, %84 overflow : i64
- %121 = llvm.getelementptr %117[%120] : (!llvm.ptr, i64) -> !llvm.ptr, f32
- llvm.store %116, %121 : f32, !llvm.ptr
- %122 = llvm.add %94, %93 : i64
- llvm.br ^bb3(%122 : i64)
- ^bb5: // pred: ^bb3
- %123 = llvm.add %84, %83 : i64
- llvm.br ^bb1(%123 : i64)
- ^bb6: // pred: ^bb1
+ omp.loop_nest (%arg41) : i64 = (%15) to (%16) step (%17) {
+ %834 = llvm.intr.stacksave : !llvm.ptr
+ llvm.br ^bb1
+ ^bb1: // pred: ^bb0
+ llvm.br ^bb2(%15 : i64)
+ ^bb2(%835: i64): // 2 preds: ^bb1, ^bb6
+ %836 = llvm.icmp "slt" %835, %18 : i64
+ llvm.cond_br %836, ^bb3, ^bb7
+ ^bb3: // pred: ^bb2
+ %837 = llvm.extractvalue %195[1] : !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)>
+ %838 = llvm.getelementptr %837[25000000] : (!llvm.ptr) -> !llvm.ptr, f32
+ %839 = llvm.mul %arg41, %18 overflow : i64
+ %840 = llvm.add %839, %835 overflow : i64
+ %841 = llvm.getelementptr inbounds|nuw %838[%840] : (!llvm.ptr, i64) -> !llvm.ptr, f32
+ llvm.store %13, %841 : f32, !llvm.ptr
+ llvm.br ^bb4(%15 : i64)
+ ^bb4(%842: i64): // 2 preds: ^bb3, ^bb5
+ %843 = llvm.icmp "slt" %842, %18 : i64
+ llvm.cond_br %843, ^bb5, ^bb6
+ ^bb5: // pred: ^bb4
+ %844 = llvm.extractvalue %168[1] : !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)>
+ %845 = llvm.getelementptr %844[25000000] : (!llvm.ptr) -> !llvm.ptr, f32
+ %846 = llvm.mul %arg41, %18 overflow : i64
+ %847 = llvm.add %846, %842 overflow : i64
+ %848 = llvm.getelementptr inbounds|nuw %845[%847] : (!llvm.ptr, i64) -> !llvm.ptr, f32
+ %849 = llvm.load %848 : !llvm.ptr -> f32
+ %850 = llvm.fmul %arg4, %849 : f32
+ %851 = llvm.mul %842, %18 overflow : i64
+ %852 = llvm.add %851, %835 overflow : i64
+ %853 = llvm.getelementptr inbounds|nuw %arg21[%852] : (!llvm.ptr, i64) -> !llvm.ptr, f32
+ %854 = llvm.load %853 : !llvm.ptr -> f32
+ %855 = llvm.fmul %850, %854 : f32
+ %856 = llvm.extractvalue %195[1] : !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)>
+ %857 = llvm.getelementptr %856[25000000] : (!llvm.ptr) -> !llvm.ptr, f32
+ %858 = llvm.mul %arg41, %18 overflow : i64
+ %859 = llvm.add %858, %835 overflow : i64
+ %860 = llvm.getelementptr inbounds|nuw %857[%859] : (!llvm.ptr, i64) -> !llvm.ptr, f32
+ %861 = llvm.load %860 : !llvm.ptr -> f32
+ %862 = llvm.fadd %861, %855 : f32
+ %863 = llvm.extractvalue %195[1] : !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)>
+ %864 = llvm.getelementptr %863[25000000] : (!llvm.ptr) -> !llvm.ptr, f32
+ %865 = llvm.mul %arg41, %18 overflow : i64
+ %866 = llvm.add %865, %835 overflow : i64
+ %867 = llvm.getelementptr inbounds|nuw %864[%866] : (!llvm.ptr, i64) -> !llvm.ptr, f32
+ llvm.store %862, %867 : f32, !llvm.ptr
+ %868 = llvm.add %842, %17 : i64
+ llvm.br ^bb4(%868 : i64)
+ ^bb6: // pred: ^bb4
+ %869 = llvm.add %835, %17 : i64
+ llvm.br ^bb2(%869 : i64)
+ ^bb7: // pred: ^bb2
+ llvm.intr.stackrestore %834 : !llvm.ptr
+ llvm.br ^bb8
+ ^bb8: // pred: ^bb7
omp.yield
}
}
@@ -206,79 +682,65 @@ module attributes {avial.target_devices = [#dlti.target_device_spec<"type" = "no
}
llvm.br ^bb4
^bb4: // 2 preds: ^bb2, ^bb3
- %66 = llvm.mlir.constant(2 : i32) : i32
- %67 = llvm.srem %66, %52 : i32
- %68 = llvm.icmp "eq" %47, %67 : i32
- llvm.cond_br %68, ^bb5, ^bb6
+ %522 = llvm.icmp "eq" %87, %20 : i32
+ llvm.cond_br %522, ^bb5, ^bb6
^bb5: // pred: ^bb4
- %69 = llvm.mlir.constant(500 : index) : i64
- %70 = llvm.mlir.constant(1000 : index) : i64
- %71 = llvm.mlir.constant(1 : index) : i64
omp.parallel {
omp.wsloop {
- omp.loop_nest (%arg41) : i64 = (%69) to (%70) step (%71) {
- %80 = llvm.mlir.constant(0 : index) : i64
- %81 = llvm.mlir.constant(0 : index) : i64
- %82 = llvm.mlir.constant(1000 : index) : i64
- %83 = llvm.mlir.constant(1 : index) : i64
- llvm.br ^bb1(%81 : i64)
- ^bb1(%84: i64): // 2 preds: ^bb0, ^bb5
- %85 = llvm.icmp "slt" %84, %82 : i64
- llvm.cond_br %85, ^bb2, ^bb6
- ^bb2: // pred: ^bb1
- %86 = llvm.extractvalue %7[1] : !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)>
- %87 = llvm.mlir.constant(1000 : index) : i64
- %88 = llvm.mul %80, %87 overflow : i64
- %89 = llvm.add %88, %84 overflow : i64
- %90 = llvm.getelementptr %86[%89] : (!llvm.ptr, i64) -> !llvm.ptr, f32
- %91 = llvm.load %90 : !llvm.ptr -> f32
- %92 = llvm.fmul %91, %arg5 : f32
- %93 = llvm.extractvalue %7[1] : !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)>
- %94 = llvm.mlir.constant(1000 : index) : i64
- %95 = llvm.mul %80, %94 overflow : i64
- %96 = llvm.add %95, %84 overflow : i64
- %97 = llvm.getelementptr %93[%96] : (!llvm.ptr, i64) -> !llvm.ptr, f32
- llvm.store %92, %97 : f32, !llvm.ptr
- %98 = llvm.mlir.constant(0 : index) : i64
- %99 = llvm.mlir.constant(1000 : index) : i64
- %100 = llvm.mlir.constant(1 : index) : i64
- llvm.br ^bb3(%98 : i64)
- ^bb3(%101: i64): // 2 preds: ^bb2, ^bb4
- %102 = llvm.icmp "slt" %101, %99 : i64
- llvm.cond_br %102, ^bb4, ^bb5
- ^bb4: // pred: ^bb3
- %103 = llvm.extractvalue %39[1] : !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)>
- %104 = llvm.mlir.constant(1000 : index) : i64
- %105 = llvm.mul %80, %104 overflow : i64
- %106 = llvm.add %105, %101 overflow : i64
- %107 = llvm.getelementptr %103[%106] : (!llvm.ptr, i64) -> !llvm.ptr, f32
- %108 = llvm.load %107 : !llvm.ptr -> f32
- %109 = llvm.extractvalue %15[1] : !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)>
- %110 = llvm.mlir.constant(1000 : index) : i64
- %111 = llvm.mul %101, %110 overflow : i64
- %112 = llvm.add %111, %84 overflow : i64
- %113 = llvm.getelementptr %109[%112] : (!llvm.ptr, i64) -> !llvm.ptr, f32
- %114 = llvm.load %113 : !llvm.ptr -> f32
- %115 = llvm.fmul %108, %114 : f32
- %116 = llvm.extractvalue %7[1] : !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)>
- %117 = llvm.mlir.constant(1000 : index) : i64
- %118 = llvm.mul %80, %117 overflow : i64
- %119 = llvm.add %118, %84 overflow : i64
- %120 = llvm.getelementptr %116[%119] : (!llvm.ptr, i64) -> !llvm.ptr, f32
- %121 = llvm.load %120 : !llvm.ptr -> f32
- %122 = llvm.fadd %121, %115 : f32
- %123 = llvm.extractvalue %7[1] : !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)>
- %124 = llvm.mlir.constant(1000 : index) : i64
- %125 = llvm.mul %80, %124 overflow : i64
- %126 = llvm.add %125, %84 overflow : i64
- %127 = llvm.getelementptr %123[%126] : (!llvm.ptr, i64) -> !llvm.ptr, f32
- llvm.store %122, %127 : f32, !llvm.ptr
- %128 = llvm.add %101, %100 : i64
- llvm.br ^bb3(%128 : i64)
- ^bb5: // pred: ^bb3
- %129 = llvm.add %84, %83 : i64
- llvm.br ^bb1(%129 : i64)
- ^bb6: // pred: ^bb1
+ omp.loop_nest (%arg41) : i64 = (%15) to (%16) step (%17) {
+ %834 = llvm.intr.stacksave : !llvm.ptr
+ llvm.br ^bb1
+ ^bb1: // pred: ^bb0
+ llvm.br ^bb2(%15 : i64)
+ ^bb2(%835: i64): // 2 preds: ^bb1, ^bb6
+ %836 = llvm.icmp "slt" %835, %18 : i64
+ llvm.cond_br %836, ^bb3, ^bb7
+ ^bb3: // pred: ^bb2
+ %837 = llvm.extractvalue %249[1] : !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)>
+ %838 = llvm.getelementptr %837[50000000] : (!llvm.ptr) -> !llvm.ptr, f32
+ %839 = llvm.mul %arg41, %18 overflow : i64
+ %840 = llvm.add %839, %835 overflow : i64
+ %841 = llvm.getelementptr inbounds|nuw %838[%840] : (!llvm.ptr, i64) -> !llvm.ptr, f32
+ llvm.store %13, %841 : f32, !llvm.ptr
+ llvm.br ^bb4(%15 : i64)
+ ^bb4(%842: i64): // 2 preds: ^bb3, ^bb5
+ %843 = llvm.icmp "slt" %842, %18 : i64
+ llvm.cond_br %843, ^bb5, ^bb6
+ ^bb5: // pred: ^bb4
+ %844 = llvm.extractvalue %222[1] : !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)>
+ %845 = llvm.getelementptr %844[50000000] : (!llvm.ptr) -> !llvm.ptr, f32
+ %846 = llvm.mul %arg41, %18 overflow : i64
+ %847 = llvm.add %846, %842 overflow : i64
+ %848 = llvm.getelementptr inbounds|nuw %845[%847] : (!llvm.ptr, i64) -> !llvm.ptr, f32
+ %849 = llvm.load %848 : !llvm.ptr -> f32
+ %850 = llvm.fmul %arg4, %849 : f32
+ %851 = llvm.mul %842, %18 overflow : i64
+ %852 = llvm.add %851, %835 overflow : i64
+ %853 = llvm.getelementptr inbounds|nuw %arg21[%852] : (!llvm.ptr, i64) -> !llvm.ptr, f32
+ %854 = llvm.load %853 : !llvm.ptr -> f32
+ %855 = llvm.fmul %850, %854 : f32
+ %856 = llvm.extractvalue %249[1] : !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)>
+ %857 = llvm.getelementptr %856[50000000] : (!llvm.ptr) -> !llvm.ptr, f32
+ %858 = llvm.mul %arg41, %18 overflow : i64
+ %859 = llvm.add %858, %835 overflow : i64
+ %860 = llvm.getelementptr inbounds|nuw %857[%859] : (!llvm.ptr, i64) -> !llvm.ptr, f32
+ %861 = llvm.load %860 : !llvm.ptr -> f32
+ %862 = llvm.fadd %861, %855 : f32
+ %863 = llvm.extractvalue %249[1] : !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)>
+ %864 = llvm.getelementptr %863[50000000] : (!llvm.ptr) -> !llvm.ptr, f32
+ %865 = llvm.mul %arg41, %18 overflow : i64
+ %866 = llvm.add %865, %835 overflow : i64
+ %867 = llvm.getelementptr inbounds|nuw %864[%866] : (!llvm.ptr, i64) -> !llvm.ptr, f32
+ llvm.store %862, %867 : f32, !llvm.ptr
+ %868 = llvm.add %842, %17 : i64
+ llvm.br ^bb4(%868 : i64)
+ ^bb6: // pred: ^bb4
+ %869 = llvm.add %835, %17 : i64
+ llvm.br ^bb2(%869 : i64)
+ ^bb7: // pred: ^bb2
+ llvm.intr.stackrestore %834 : !llvm.ptr
+ llvm.br ^bb8
+ ^bb8: // pred: ^bb7
omp.yield
}
}
@@ -286,79 +748,65 @@ module attributes {avial.target_devices = [#dlti.target_device_spec<"type" = "no
}
llvm.br ^bb6
^bb6: // 2 preds: ^bb4, ^bb5
- %72 = llvm.mlir.constant(3 : i32) : i32
- %73 = llvm.srem %72, %52 : i32
- %74 = llvm.icmp "eq" %47, %73 : i32
- llvm.cond_br %74, ^bb7, ^bb8
+ %523 = llvm.icmp "eq" %87, %21 : i32
+ llvm.cond_br %523, ^bb7, ^bb8
^bb7: // pred: ^bb6
- %75 = llvm.mlir.constant(0 : index) : i64
- %76 = llvm.mlir.constant(500 : index) : i64
- %77 = llvm.mlir.constant(1 : index) : i64
omp.parallel {
omp.wsloop {
- omp.loop_nest (%arg41) : i64 = (%75) to (%76) step (%77) {
- %80 = llvm.mlir.constant(0 : index) : i64
- %81 = llvm.mlir.constant(0 : index) : i64
- %82 = llvm.mlir.constant(1000 : index) : i64
- %83 = llvm.mlir.constant(1 : index) : i64
- llvm.br ^bb1(%81 : i64)
- ^bb1(%84: i64): // 2 preds: ^bb0, ^bb5
- %85 = llvm.icmp "slt" %84, %82 : i64
- llvm.cond_br %85, ^bb2, ^bb6
- ^bb2: // pred: ^bb1
- %86 = llvm.extractvalue %7[1] : !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)>
- %87 = llvm.mlir.constant(1000 : index) : i64
- %88 = llvm.mul %80, %87 overflow : i64
- %89 = llvm.add %88, %84 overflow : i64
- %90 = llvm.getelementptr %86[%89] : (!llvm.ptr, i64) -> !llvm.ptr, f32
- %91 = llvm.load %90 : !llvm.ptr -> f32
- %92 = llvm.fmul %91, %arg5 : f32
- %93 = llvm.extractvalue %7[1] : !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)>
- %94 = llvm.mlir.constant(1000 : index) : i64
- %95 = llvm.mul %80, %94 overflow : i64
- %96 = llvm.add %95, %84 overflow : i64
- %97 = llvm.getelementptr %93[%96] : (!llvm.ptr, i64) -> !llvm.ptr, f32
- llvm.store %92, %97 : f32, !llvm.ptr
- %98 = llvm.mlir.constant(0 : index) : i64
- %99 = llvm.mlir.constant(1000 : index) : i64
- %100 = llvm.mlir.constant(1 : index) : i64
- llvm.br ^bb3(%98 : i64)
- ^bb3(%101: i64): // 2 preds: ^bb2, ^bb4
- %102 = llvm.icmp "slt" %101, %99 : i64
- llvm.cond_br %102, ^bb4, ^bb5
- ^bb4: // pred: ^bb3
- %103 = llvm.extractvalue %39[1] : !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)>
- %104 = llvm.mlir.constant(1000 : index) : i64
- %105 = llvm.mul %80, %104 overflow : i64
- %106 = llvm.add %105, %101 overflow : i64
- %107 = llvm.getelementptr %103[%106] : (!llvm.ptr, i64) -> !llvm.ptr, f32
- %108 = llvm.load %107 : !llvm.ptr -> f32
- %109 = llvm.extractvalue %15[1] : !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)>
- %110 = llvm.mlir.constant(1000 : index) : i64
- %111 = llvm.mul %101, %110 overflow : i64
- %112 = llvm.add %111, %84 overflow : i64
- %113 = llvm.getelementptr %109[%112] : (!llvm.ptr, i64) -> !llvm.ptr, f32
- %114 = llvm.load %113 : !llvm.ptr -> f32
- %115 = llvm.fmul %108, %114 : f32
- %116 = llvm.extractvalue %7[1] : !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)>
- %117 = llvm.mlir.constant(1000 : index) : i64
- %118 = llvm.mul %80, %117 overflow : i64
- %119 = llvm.add %118, %84 overflow : i64
- %120 = llvm.getelementptr %116[%119] : (!llvm.ptr, i64) -> !llvm.ptr, f32
- %121 = llvm.load %120 : !llvm.ptr -> f32
- %122 = llvm.fadd %121, %115 : f32
- %123 = llvm.extractvalue %7[1] : !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)>
- %124 = llvm.mlir.constant(1000 : index) : i64
- %125 = llvm.mul %80, %124 overflow : i64
- %126 = llvm.add %125, %84 overflow : i64
- %127 = llvm.getelementptr %123[%126] : (!llvm.ptr, i64) -> !llvm.ptr, f32
- llvm.store %122, %127 : f32, !llvm.ptr
- %128 = llvm.add %101, %100 : i64
- llvm.br ^bb3(%128 : i64)
- ^bb5: // pred: ^bb3
- %129 = llvm.add %84, %83 : i64
- llvm.br ^bb1(%129 : i64)
- ^bb6: // pred: ^bb1
+ omp.loop_nest (%arg41) : i64 = (%15) to (%16) step (%17) {
+ %834 = llvm.intr.stacksave : !llvm.ptr
+ llvm.br ^bb1
+ ^bb1: // pred: ^bb0
+ llvm.br ^bb2(%15 : i64)
+ ^bb2(%835: i64): // 2 preds: ^bb1, ^bb6
+ %836 = llvm.icmp "slt" %835, %18 : i64
+ llvm.cond_br %836, ^bb3, ^bb7
+ ^bb3: // pred: ^bb2
+ %837 = llvm.extractvalue %303[1] : !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)>
+ %838 = llvm.getelementptr %837[75000000] : (!llvm.ptr) -> !llvm.ptr, f32
+ %839 = llvm.mul %arg41, %18 overflow : i64
+ %840 = llvm.add %839, %835 overflow : i64
+ %841 = llvm.getelementptr inbounds|nuw %838[%840] : (!llvm.ptr, i64) -> !llvm.ptr, f32
+ llvm.store %13, %841 : f32, !llvm.ptr
+ llvm.br ^bb4(%15 : i64)
+ ^bb4(%842: i64): // 2 preds: ^bb3, ^bb5
+ %843 = llvm.icmp "slt" %842, %18 : i64
+ llvm.cond_br %843, ^bb5, ^bb6
+ ^bb5: // pred: ^bb4
+ %844 = llvm.extractvalue %276[1] : !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)>
+ %845 = llvm.getelementptr %844[75000000] : (!llvm.ptr) -> !llvm.ptr, f32
+ %846 = llvm.mul %arg41, %18 overflow