wire: 优化赋值操作，去除 Retain 指令

3dgen · 3dgen · commit 802c702ab949 · 2026-02-26T17:15:12.000+08:00
diff --git a/internal/wire/function.go b/internal/wire/function.go
@@ -166,11 +166,8 @@ func (f *Function) EndBody() {
 
 			param.name = "$" + param.name
 			fb.emit(param)
-			if hasChunk {
-				param.init = NewRetain(NewGet(&np, np.pos), np.pos)
-			} else {
-				param.init = NewGet(&np, np.pos)
-			}
+
+			param.init = NewGet(&np, np.pos)
 
 			f.params[i] = &np
 		}
@@ -309,9 +306,6 @@ func rc_stmt(s Stmt, inloop bool, d *Block) {
 	case *Alloc:
 		s.init = rc_expr(s.init, inloop, false, false, d, &pre)
 		d.Stmts = append(d.Stmts, pre...)
-		if s.init != nil && rtimp.hasChunk(s.init.Type()) && !s.init.retained() {
-			s.init = NewRetain(s.init, s.init.Pos())
-		}
 		d.emit(s)
 
 	case *Get:
@@ -322,33 +316,42 @@ func rc_stmt(s Stmt, inloop bool, d *Block) {
 			s.Lhs[i] = rc_expr(s.Lhs[i], inloop, true, false, d, &pre)
 		}
 
-		for i := range s.Rhs {
-			s.Rhs[i] = rc_expr(s.Rhs[i], inloop, false, false, d, &pre)
-			if rtimp.hasChunk(s.Rhs[i].Type()) && !s.Rhs[i].retained() {
-				s.Rhs[i] = NewRetain(s.Rhs[i], s.Rhs[i].Pos())
+		rhNeedRetain := make([]bool, len(s.Lhs))
+		if len(s.Lhs) == len(s.Rhs) {
+			for i := range s.Rhs {
+				s.Rhs[i] = rc_expr(s.Rhs[i], inloop, false, false, d, &pre)
+				if rtimp.hasChunk(s.Rhs[i].Type()) && !s.Rhs[i].retained() {
+					rhNeedRetain[i] = true
+				}
+			}
+		} else {
+			// rh 是元组
+			notRetained := rtimp.hasChunk(s.Rhs[0].Type()) && !s.Rhs[0].retained()
+			for i := range rhNeedRetain {
+				rhNeedRetain[i] = notRetained
 			}
 		}
 
 		d.Stmts = append(d.Stmts, pre...)
 
-		allAssignable := true
-		assignable := make([]bool, len(s.Lhs))
+		allLhsAssignable := true
+		lhAssignable := make([]bool, len(s.Lhs))
 		lhs := make([]Var, len(s.Lhs))
 		for i, lh := range s.Lhs {
 			if lh == nil {
 				lhs[i] = nil
-				assignable[i] = true
+				lhAssignable[i] = true
 				continue
 			}
 
 			if v, ok := lh.(Var); ok && v.Kind() == Register {
 				lhs[i] = v
-				assignable[i] = true
+				lhAssignable[i] = true
 				continue
 			}
 
-			allAssignable = false
-			assignable[i] = false
+			allLhsAssignable = false
+			lhAssignable[i] = false
 			if get, ok := lh.(*Get); ok {
 				if v, ok := get.Loc.(Var); ok && v.Kind() == Register {
 					lhs[i] = v
@@ -361,8 +364,10 @@ func rc_stmt(s Stmt, inloop bool, d *Block) {
 			lhs[i] = loc
 		}
 
-		if allAssignable {
-			d.emit(NewAssignN(lhs, s.Rhs, s.pos))
+		if allLhsAssignable {
+			assign := NewAssignN(lhs, s.Rhs, s.pos)
+			copy(assign.needRetain, rhNeedRetain)
+			d.emit(assign)
 		} else {
 			rhs := make([]Expr, len(s.Lhs))
 
@@ -386,31 +391,41 @@ func rc_stmt(s Stmt, inloop bool, d *Block) {
 				loc := lhs[i]
 				rh := rhs[i]
 
-				if assignable[i] {
-					d.emit(NewAssign(loc, rh, s.pos))
+				if lhAssignable[i] {
+					assign := NewAssign(loc, rh, s.pos)
+					assign.needRetain[0] = rhNeedRetain[i]
+					d.emit(assign)
 					continue
 				}
 
 				if v, ok := rh.(Var); ok {
-					d.emit(NewStore(loc, v, s.pos))
+					store := NewStore(loc, v, s.pos)
+					store.needRetain = rhNeedRetain[i]
+					d.emit(store)
 					continue
 				}
 
 				if get, ok := rh.(*Get); ok {
 					if v, ok := get.Loc.(Var); ok && v.Kind() == Register {
-						d.emit(NewStore(loc, v, s.pos))
+						store := NewStore(loc, v, s.pos)
+						store.needRetain = rhNeedRetain[i]
+						d.emit(store)
 						continue
 					}
 				}
 
 				if c, ok := rh.(*Const); ok {
-					d.emit(NewStore(loc, c, s.pos))
+					store := NewStore(loc, c, s.pos)
+					store.needRetain = false
+					d.emit(store)
 					continue
 				}
 
 				imv := NewImv(d.newTempVarName(), rh, s.pos)
 				d.emit(imv)
-				d.emit(NewStore(loc, imv, s.pos))
+				store := NewStore(loc, imv, s.pos)
+				store.needRetain = rhNeedRetain[i]
+				d.emit(store)
 			}
 		}
 
@@ -436,8 +451,8 @@ func rc_stmt(s Stmt, inloop bool, d *Block) {
 		rc_block(s.Body, true, l.Body)
 		rc_block(s.Post, true, l.Post)
 
-	case *Retain:
-		d.emit(s)
+	//case *Retain:
+	//	d.emit(s)
 
 	case *Drop:
 		d.emit(s)
@@ -556,7 +571,7 @@ func (f *Function) autoDrop(b *Block) {
 			f.autoDrop(s.Body)
 			f.autoDrop(s.Post)
 
-		case *Get, *Set, *Assign, *Store, *Br, *Return, *Unop, *Biop, *Retain, *Drop:
+		case *Get, *Set, *Assign, *Store, *Br, *Return, *Unop, *Biop, *Drop:
 			continue
 
 		default:
@@ -621,8 +636,8 @@ func (f *Function) allocVR_stmt(s Stmt, inloop bool) {
 	case *Drop:
 		f.dropVR_tank(s.X.Tank())
 
-	case *Retain:
-		panic("Retain should not be here")
+	//case *Retain:
+	//	panic("Retain should not be here")
 
 	case *Br, *Return:
 
@@ -691,8 +706,8 @@ func (f *Function) allocVR_expr(e Expr, inloop bool) {
 	//	f.allocVR_expr(e.X, inloop)
 	//	f.allocVR_var(e.Imv, inloop)
 
-	case *Retain:
-		f.allocVR_expr(e.X, inloop)
+	//case *Retain:
+	//	f.allocVR_expr(e.X, inloop)
 
 	default:
 		panic(fmt.Sprintf("Todo: %s", e.(Stmt).String()))
@@ -865,8 +880,8 @@ func getReplace_expr(e Expr) (ret Expr) {
 		e.X = getReplace_expr(e.X)
 		e.Y = getReplace_expr(e.Y)
 
-	case *Retain:
-		e.X = getReplace_expr(e.X)
+	//case *Retain:
+	//	e.X = getReplace_expr(e.X)
 
 	case *Call:
 		var call_common *CallCommon
diff --git a/internal/wire/ins_expr_unop_biop.go b/internal/wire/ins_expr_unop_biop.go
@@ -167,30 +167,30 @@ Combo: 组合指令，将多个指令组合成一个指令，实现了 Expr 接
 //	return v
 //}
 
-/**************************************
-Retain: Retain 指令，引用计数 +1，Retain 指令实现了 Expr，返回 X 本身
-**************************************/
-
-type Retain struct {
-	aStmt
-	X Expr
-}
-
-func (i *Retain) Name() string   { return i.String() }
-func (i *Retain) Type() Type     { return i.X.Type() }
-func (i *Retain) retained() bool { panic("") }
-func (i *Retain) String() string { return fmt.Sprintf("retain(%s)", i.X.Name()) }
-
-// 生成一条 Retain 指令
-func NewRetain(x Expr, pos int) *Retain {
-	if x == nil {
-		panic("x is nil")
-	}
-	v := &Retain{X: x}
-	v.Stringer = v
-	v.pos = pos
-	return v
-}
+///**************************************
+//Retain: Retain 指令，引用计数 +1，Retain 指令实现了 Expr，返回 X 本身
+//**************************************/
+//
+//type Retain struct {
+//	aStmt
+//	X Expr
+//}
+//
+//func (i *Retain) Name() string   { return i.String() }
+//func (i *Retain) Type() Type     { return i.X.Type() }
+//func (i *Retain) retained() bool { panic("") }
+//func (i *Retain) String() string { return fmt.Sprintf("retain(%s)", i.X.Name()) }
+//
+//// 生成一条 Retain 指令
+//func NewRetain(x Expr, pos int) *Retain {
+//	if x == nil {
+//		panic("x is nil")
+//	}
+//	v := &Retain{X: x}
+//	v.Stringer = v
+//	v.pos = pos
+//	return v
+//}
 
 /**************************************
 DupRef: DupRef 指令，引用复制，DupRef 指令实现了 Expr，返回 X
diff --git a/internal/wire/ins_stmt_block.go b/internal/wire/ins_stmt_block.go
@@ -308,8 +308,8 @@ func exprContainsVar(expr Expr, v Var) bool {
 	case *Biop:
 		return exprContainsVar(e.X, v) || exprContainsVar(e.Y, v)
 
-	case *Retain:
-		return exprContainsVar(e.X, v)
+	//case *Retain:
+	//	return exprContainsVar(e.X, v)
 
 	//case *Combo:
 	//	for _, stmt := range e.Stmts {
diff --git a/internal/wire/ins_stmt_set_assign_store.go b/internal/wire/ins_stmt_set_assign_store.go
@@ -89,29 +89,35 @@ Assign: Assign 指令，将 Rhs 赋值给 Lhs
   - Assgin 支持多赋值
   - Lh 必须为 Register 型变量
   - Rh 可能为元组（Tuple），此时 Rhs 的长度应为 1，Lhs 的长度应为元组长度
-  - 向 nil 的 Lh 赋值是合法的，这等价于向匿名变量 _ 赋值，此时若 Rh 已 retain，应触发 release
+  - 向 nil 的 Lh 赋值是合法的，这等价于向匿名变量 _ 赋值
 **************************************/
 
 type Assign struct {
 	aStmt
-	Lhs []Var
-	Rhs []Expr
+	Lhs        []Var
+	needRetain []bool
+	Rhs        []Expr
 }
 
 func (i *Assign) String() string {
 	var sb strings.Builder
 
-	for i, lh := range i.Lhs {
-		if i > 0 {
+	for j, lh := range i.Lhs {
+		if j > 0 {
 			sb.WriteString(", ")
 		}
 
 		if lh == nil {
 			sb.WriteRune('_')
-			continue
+			if !i.needRetain[j] {
+				sb.WriteString("↓")
+			}
+		} else {
+			sb.WriteString(lh.Name())
+			if i.needRetain[j] && rtimp.hasChunk(lh.Type()) {
+				sb.WriteString("↑")
+			}
 		}
-
-		sb.WriteString(lh.Name())
 	}
 
 	sb.WriteString(" = ")
@@ -134,6 +140,7 @@ func NewAssignN(lhs []Var, rhs []Expr, pos int) *Assign {
 	v.Stringer = v
 	v.Lhs = lhs
 	v.Rhs = rhs
+	v.needRetain = make([]bool, len(lhs))
 	v.pos = pos
 	return v
 }
@@ -160,12 +167,17 @@ Store: Store 指令，将 Val 存储到 Loc 指定的位置
 
 type Store struct {
 	aStmt
-	Loc Var
-	Val Expr
+	Loc        Var
+	needRetain bool
+	Val        Expr
 }
 
 func (i *Store) String() string {
-	return fmt.Sprintf("store(%s, %s)", i.Loc.Name(), i.Val.Name())
+	if i.needRetain && rtimp.hasChunk(i.Val.Type()) {
+		return fmt.Sprintf("store(%s↑, %s)", i.Loc.Name(), i.Val.Name())
+	} else {
+		return fmt.Sprintf("store(%s, %s)", i.Loc.Name(), i.Val.Name())
+	}
 }
 
 func NewStore(loc Var, val Expr, pos int) *Store {
