第 3 课:Block 和 Region
文章目录
好,继续第 3 课。这节我们学习 MLIR 里非常关键的两个概念:
Block(基本块) 和 Region(区域)。
它们是理解函数、if、for、控制流,以及为什么 MLIR 能表达“嵌套结构”的基础。
第 3 课:Block 和 Region
先看最熟悉的代码:
func.func @add(%a: i32, %b: i32) -> i32 {
%0 = arith.addi %a, %b : i32
return %0 : i32
}
你可能自然地认为:
{
...
}
只是“函数体”。
但从 MLIR 的角度看,这里面其实是:
func.func Operation
│
▼
Region
│
▼
Block
│
├── arith.addi
└── return
这就是今天最核心的结构。
1. Block 是什么?
Block 可以先理解为:
一组顺序执行的 Operation。
例如:
^bb0(%a: i32, %b: i32):
%0 = arith.addi %a, %b : i32
return %0 : i32
这里:
^bb0
就是一个 Block。
它里面包含:
arith.addi
return
两个 Operation。
所以:
Block
├── Operation
├── Operation
├── Operation
└── ...
你可以暂时把它类比成 LLVM IR 的 basic block。
2. Block 可以有参数
注意:
^bb0(%a: i32, %b: i32):
这里:
%a
%b
叫:
Block Arguments
也就是 Block 参数。
它们也是:
Value
所以我们上一课说:
Value 的来源主要有:
1. Operation Result
2. Block Argument
比如:
^bb0(%a: i32, %b: i32):
%0 = arith.addi %a, %b : i32
这里:
%a
%b
来自 Block Argument,
而:
%0
来自 Operation Result。
因此:
Block Arguments
%a %b
\ /
\ /
arith.addi
|
v
%0
3. 为什么函数参数看起来不像 Block Argument?
看这个:
func.func @add(%a: i32, %b: i32) -> i32 {
%0 = arith.addi %a, %b : i32
return %0 : i32
}
你看不到:
^bb0
这是因为 MLIR 的文本格式把函数入口块做了简写。
概念上,可以理解为:
func.func @add(%a: i32, %b: i32) -> i32 {
^bb0(%a: i32, %b: i32):
%0 = arith.addi %a, %b : i32
return %0 : i32
}
虽然实际语法并不是要求你这么重复写,但从结构上理解是对的:
函数参数,本质上就是函数 body 中入口 Block 的 arguments。
这一点非常重要。
4. Region 是什么?
Region 可以理解为:
一个包含若干 Block 的容器。
结构是:
Region
├── Block 0
├── Block 1
├── Block 2
└── ...
所以完整层次变成:
Operation
│
▼
Region
│
├── Block
│ ├── Operation
│ └── Operation
│
└── Block
├── Operation
└── Operation
你会发现这里出现了递归:
Operation
contains Region
Region
contains Block
Block
contains Operation
于是:
Operation
↓
Region
↓
Block
↓
Operation
↓
Region
↓
Block
↓
...
这就是 MLIR 很强的地方之一。
5. func.func 本身也是 Operation
这是很多初学者第一次学 MLIR 时容易忽略的。
比如:
func.func @add(%a: i32, %b: i32) -> i32 {
%0 = arith.addi %a, %b : i32
return %0 : i32
}
你可能觉得:
func.func
是某种特殊语法。
但其实:
func.func 也是 Operation
它大概长这样:
func.func Operation
│
├── Attributes
│ ├── 函数名 = add
│ └── 函数类型 = (i32, i32) -> i32
│
└── Region
│
└── Block
├── arith.addi
└── func.return
所以函数不是 MLIR 之外的特殊结构。
它只是:
一个拥有 Region 的 Operation。
这句话非常关键。
6. 为什么 Operation 里要允许 Region?
因为这样可以表达:
嵌套控制结构
比如 if。
看一个简单示意:
scf.if %cond {
%0 = arith.addi %a, %b : i32
...
} else {
%1 = arith.subi %a, %b : i32
...
}
scf.if 本身是一个 Operation。
但它内部有两个 Region:
scf.if Operation
│
├── then Region
│ └── Block
│ └── ...
│
└── else Region
└── Block
└── ...
也就是:
scf.if
/ \
/ \
then Region else Region
| |
Block Block
| |
Operations Operations
这和很多传统 IR 很不一样。
7. for 也一样
比如:
scf.for %i = %c0 to %c10 step %c1 {
...
}
这里:
scf.for
也是一个 Operation。
它内部带一个 Region:
scf.for Operation
│
▼
Region
│
▼
Block
│
└── loop body operations
所以循环体不是“特殊语法”。
它就是:
Operation 的 Region
8. 这和 LLVM IR 有什么区别?
LLVM IR 通常会把 if:
if (x < 10) {
foo();
} else {
bar();
}
展开成基本块:
entry
|
v
cond
/ \
v v
then else
\ /
v v
merge
也就是说控制流结构很早就“扁平化”了。
而 MLIR 可以在较高层继续保持:
if
├── then region
└── else region
甚至:
for
└── loop body region
这种结构。
这叫:
Structured Control Flow
也就是结构化控制流。
这样做的好处是:
编译器还能知道“这是一个 if”、“这是一个 for”。
高层语义没有过早丢失。
9. 一个完整层次图
现在来看:
func.func @foo(%a: i32, %b: i32) -> i32 {
%0 = arith.addi %a, %b : i32
return %0 : i32
}
可以拆成:
Module
│
└── func.func
│
└── Region
│
└── Block
│
├── arith.addi
│ ├── operand: %a
│ ├── operand: %b
│ └── result: %0
│
└── func.return
└── operand: %0
其实再往外一层通常还有:
module {
func.func @foo(...) {
...
}
}
这里:
module
同样是一个 Operation。
所以:
builtin.module Operation
│
└── Region
│
└── Block
│
└── func.func Operation
│
└── Region
│
└── Block
│
├── arith.addi
└── func.return
看到没有?
MLIR 本质上是一棵嵌套树。
10. 一个很重要的思想:Operation 是统一抽象
传统编译器里可能有很多不同概念:
函数
循环
if
加法
调用
模块
而 MLIR 尝试统一成:
Operation
区别只是:
有的 Operation 有 Region
有的没有
有的有 Result
有的没有
有的有 Operand
有的没有
有的有 Attribute
有的没有
例如:
arith.addi
没有 Region。
但:
func.func
有 Region。
scf.if
甚至可以有两个 Region。
11. Region 不一定只有一个 Block
这是一个非常重要的点。
Region 可以是:
Region
└── Block
也可以是:
Region
├── Block A
├── Block B
└── Block C
例如低层控制流:
^bb0:
cf.cond_br %cond, ^bb1, ^bb2
^bb1:
...
cf.br ^bb3
^bb2:
...
cf.br ^bb3
^bb3:
return
这时 Region 里就有多个 Block。
结构变成:
Region
│
├── ^bb0
│
├── ^bb1
│
├── ^bb2
│
└── ^bb3
这已经和 LLVM IR 的 CFG 很接近了。
12. Block 之间怎么传值?
这是下一步很关键的地方。
假设:
^bb0:
cf.br ^bb1(%x : i32)
^bb1(%y: i32):
...
可以理解成:
bb0 里面的 %x
│
│ branch
▼
bb1 的参数 %y
也就是说:
Block Argument
除了函数参数之外,还可以承担类似 LLVM IR 里 phi 的作用。
你现在先知道这一点就够了,后面学控制流时我们会专门讲。
13. Region 和 Scope
Region 通常还会形成 Value 的作用域。
例如:
scf.if %cond {
%0 = arith.addi %a, %b : i32
}
这里 %0 是在这个 Region 内创建的。
通常不能随便在 Region 外直接引用:
inside region:
%0
然后:
outside region:
使用 %0
如果你想把值从 Region 传出去,一般需要通过 Operation 的 Result/yield 机制。
例如以后你会看到:
%result = scf.if %cond -> (i32) {
%x = ...
scf.yield %x : i32
} else {
%y = ...
scf.yield %y : i32
}
这里就是:
Region 内部 Value
↓
scf.yield
↓
scf.if Operation Result
↓
%result
这个机制很漂亮,后面会专门讲。
现在把前 3 课连起来
我们目前已经学到:
MLIR
│
├── Operation
│ │
│ ├── Operand
│ ├── Result
│ ├── Attribute
│ └── Region
│
├── Region
│ └── Block
│
└── Block
│
├── Arguments
└── Operations
而:
Operand
Result
Block Argument
都和:
Value
有关。
可以画成完整关系:
Operation
┌──────┼──────┐
│ │ │
Operands Results Regions
│ │ │
│ │ ▼
│ │ Block
│ │ │
│ │ ├── Block Arguments
│ │ └── Operations
│ │
└── Value ─────┘
一个检查题
看看下面代码:
func.func @square(%x: i32) -> i32 {
%result = arith.muli %x, %x : i32
return %result : i32
}
你现在应该能说出:
func.func
是一个 Operation。
它内部有:
1 个 Region
这个 Region 里有:
1 个 Block
Block 参数是:
%x
Block 内有两个 Operation:
arith.muli
func.return
arith.muli 有:
2 个 Operand
1 个 Result
Result 是:
%result
如果这些你都能顺下来,第 3 课就掌握了。
第 3 课只记 4 句话
第一句:
Block = 一组 Operation
第二句:
Region = 一组 Block
第三句:
Operation 可以拥有 Region
第四句最重要:
Operation → Region → Block → Operation
这让 MLIR 能自然表达:
函数
if
for
嵌套循环
各种高层结构
而不用一开始就把它们扁平化成 CFG。
下一课我们继续学习 SSA、Block Argument,以及它为什么可以替代 LLVM 中很多 phi node 的使用方式。这节之后,你会开始真正看懂 MLIR 的控制流。

评论
登录后参与技术讨论,分享你的经验与见解。
登录 / 注册暂无评论