embed:reduce binary size

[luoliwoshang]

background

esp32c3/esp32 target

will got DRAM overflowed

ld.lld: error: region DRAM overflowed by .data and .bss sections
ld.lld: error: region DRAM overflowed by .data and .bss sections
ld.lld: error: region DRAM overflowed by .data and .bss sections
ld.lld: error: region DRAM overflowed by .data and .bss sections

related issue

• embed(esp32c3): cl/_testgo/abimethod fail #1569

resolution

• ssa: abi type global constant data #1450
  • fix(runtime): make NewItab tolerate unreachable IFn entries #1576

---

Reflect Keep Live

 type Foo struct{}

  func (f *Foo) Method1() { println("1") }
  func (f *Foo) Method2() { println("2") }  // no body call
  func (f *Foo) method3() { println("3") }  // private

  func main() {
      f := &Foo{}

     // convert to interface
      v := reflect.ValueOf(f)

      // compile know it convert to a interface ! keep all public method!
  }

直接调用：有显式调用或被内联展开的函数，会被标记可达，不会裁。

• 接口路径：被接口断言/转换用到的类型，其匹配到的接口方法（R_USEIFACE、R_USEIFACEMETHOD、R_METHODOFF）会被标记可达；否则方法表入口写成 -1。
• 反射路径：一旦遇到反射 Method/MethodByName/Call 等 ReflectMethod 标记或常量方法名重定位，已可达类型的导出方法（动态链接则全部方法）会被标记可达；否则可能被裁。
• 动态导出/插件/根符号：main/runtime 必需、导出/插件符号、unreachableMethod 本身为根，一定保留。
• 其他：未被上述路径触达的函数/方法（含跨包未导出、未通过接口/反射用到）会被 deadcode 判为不可达，方法表的 Ifn/Tfn 写成 -1，正文不排版进最终二进制；被弱引用且未达的
  普通符号也会被忽略/重定向。

• Proposal: Go Like linktime DCE #1587

[luoliwoshang]

DCE

##Go

• 分为SSA阶段的DCE以及链接阶段的DCE，SSA阶段的DCE实际上并没有全局视角，对于ITab的IFn和Tfn裁剪则是在Go的链接部分处理的。而这里的分析以及定位和Go的二进制是耦合的。

Go 真正意义上“把整个没用的函数/方法/类型元数据都裁掉”的 DCE，主要在 链接器里做。

链接器的 deadcode pass 基本原理是：

• 从入口符号开始做 flood fill（泛洪标记）

• 沿着符号之间的 relocations（重定位引用）一路标记“可达”

• 不可达的 text/data 符号最终被丢弃

源码注释写得很直白：“dead code elimination 的基础是从入口符号开始，沿 relocations 做 flood fill”。

值得一提的是，对于普通二进制，也会进行标记，对于我们现在的需求来说，嵌入式的入口也是多样的，对于我们的目标，是一定能去配置对应的入口的

Go 的“方法”并不像普通函数那样只有“直接调用”一条路。链接器注释总结了 可达类型的方法被调用的三种方式：

• direct call（直接调用）

• through a reachable interface type（通过接口动态派发）

• reflection：reflect.Value.Method/MethodByName、reflect.Type.Method/MethodByName 等

反射会让 DCE 变得保守

注释也写得很明确：如果发现某个函数被编译器标记成 REFLECTMETHOD（比如调用了 reflect.Value.Method，或 MethodByName 的参数不是编译期常量），链接器会放弃静态分析，直接把所有可达类型的导出方法都标记为可达。

相反，如果 MethodByName 的参数是编译期常量，编译器会发 relocation 带着方法名，链接器就只保留匹配的方法。

动态链接/插件也会让它更保守

当处于动态链接场景时，链接器会认为“未来可能出现未知接口”，因此会强制更保守（代码里直接把 reflectSeen = true）。

Tinygo

[luoliwoshang]

1. ThinLTO/自定义 LLVM pass 路线（推荐，省掉改 LLD）

• 编译时给接口断言、方法表条目、反射调用埋自定义 LLVM metadata（命名元数据或附着在全局变量/指令上，记录类型符号、方法符号）。
• 打开 ThinLTO，保留 bitcode；在全局优化阶段跑一个自定义 pass：
  • 根集合 = 入口/main、运行时必需符号、导出符号等。
  • 边 = 普通引用 + 你埋的接口/反射标记（等价 Go 的 R_USEIFACE/R_USEIFACEMETHOD/R_METHODOFF）。
  • flood 计算可达方法；对不可达的方法表条目直接在 IR 里改成 -1 或跳到 unreachable stub。
• 这样回填发生在 codegen 之前，不需要修改 lld，最终二进制里的 IFn/Tfn 已经是裁剪后的状态。

2. 对象级自定义段 + 预链接工具路线（如果不用 LTO）

• 在生成 .o 时，为方法表/接口使用写自定义节（如 .llgo.methoff、.llgo.ifaceuse），里面用标准重定位指向方法符号/类型符号，类似 Go 的 R_USEIFACE/R_METHODOFF。
• 编写一个“预链接”小工具（独立于 lld），读取所有 .o/归档，解析自定义节，做一次可达性 flood，决定哪些方法可达。
• 对不可达的条目，用 objcopy 风格的回写：把方法表常量里的 addend/目标符号改成 -1 或指向 __llgo_unreachable，再把修改后的对象交给 lld。这样 lld 仍能正常布局，且方法表已裁剪。

： 如果使用对象级自定义段+预链接的工具路线，就会带上二进制解析的心智负担，但是好处在于对于编译a包使用b包提前编译的.o，如果版本一致，那么是可以进行分析的，也能处理对应的DCE

单模块里就做 flood+回写，只能看到本包内的关系，跨包接口/反射/导出引用都看不到，结果要么过度保守（不敢裁）、要么裁错（真实跨包用到但被你当作不可达）

[luoliwoshang]

relate link

• llvm bc format https://llvm.org/docs/BitCodeFormat.html
• bc文件可以封装在原生对象中
  ： 当前LLGo可能确实会希望某些Go包会被编译为.o进行分发，有没有可能分发的时候，直接通过这个特性去带上bitcode，这样a包如果明确使用的是一个Go包就可以使用相同的可达性分析进行处理了。

[luoliwoshang]

• 如果类型的 type.* 符号未被标记可达，它的方法也不会因为反射标记被保活。
• 一旦类型可达，遇到 “需要保留方法 Foo” 的反射标记，就把该类型的 Foo 方法保活。
• deadcode 全局视角下决策可达性（全局Pass），落盘时按决策填具体值（重写回.bc参与最终编译）

[luoliwoshang]

Go的标记

• /opt/homebrew/Cellar/go@1.24/1.24.10/libexec/src/cmd/internal/objabi/reloctype.go

标记行为发生在Go的ir编译阶段 /opt/homebrew/Cellar/go@1.24/1.24.10/libexec/src/cmd/compile/internal/walk/expr.go

---

• R_USENAMEDMETHOD ： 标记泛型接口调用或通过 MethodByName("F") 查找的方法

比如这里就是对MethodByName的调用的参数进行分析，如果是常量，那么就标记为R_USENAMEDMETHOD，如果不是常量，所在的方法标记为AttrReflectMethod

	if ir.IsConst(targetName, constant.String) {
		name := constant.StringVal(targetName.Val())
		ir.CurFunc.LSym.AddRel(base.Ctxt, obj.Reloc{
			Type: objabi.R_USENAMEDMETHOD,
			Sym:  staticdata.StringSymNoCommon(name),
		})
	} else {
		ir.CurFunc.LSym.Set(obj.AttrReflectMethod, true)
	}

使用了泛型接口调用的函数，由于无法确定Foo的实际上的签名（只有Foo这个名字是确认的，所以也会需要标记上这个R_USENAMEDMETHOD表示在这个函数对Foo这个有重定位（在这个函数可达的情况下，Foo需要保活）

type I[T any] interface{ Foo() T }

// 泛型函数
func f[T any](x I[T]) {
	v := x.Foo()
	fmt.Printf("%T %v\n", v, v)
}

• R_USEIFACEMETHOD ：标记这个函数使用了某个接口类型的某个方法

比如对于不是使用泛型接口方法的，就可以通过这个来精确标记使用了哪个接口的哪个类型

	// dot.Offset() is the method index * PtrSize (the offset of code pointer in itab).
	midx := dot.Offset() / int64(types.PtrSize)
	ir.CurFunc.LSym.AddRel(base.Ctxt, obj.Reloc{
		Type: objabi.R_USEIFACEMETHOD,
		Sym:  TypeLinksym(ityp),
		Add:  InterfaceMethodOffset(ityp, midx),
	})

• R_USEIFACE：标记当前函数中，某个类型被转换为了接口。

1. 函数中出现的转换

// walkConvInterface walks an OCONVIFACE node.
func walkConvInterface(n *ir.ConvExpr, init *ir.Nodes) ir.Node {

	n.X = walkExpr(n.X, init)

	fromType := n.X.Type()
	toType := n.Type()
	if !fromType.IsInterface() && !ir.IsBlank(ir.CurFunc.Nname) {
		// skip unnamed functions (func _())
		if fromType.HasShape() {
			// Unified IR uses OCONVIFACE for converting all derived types
			// to interface type. Avoid assertion failure in
			// MarkTypeUsedInInterface, because we've marked used types
			 separately anyway.
		} else {
			reflectdata. MarkTypeUsedInInterface(fromType, ir. CurFunc.LSym)
		}
	}

2. Transformations in static assignment of global variables,

For the symbol of the global variable, mark it In the corresponding symbol of the global variable A, the type to the right of the equal sign will be converted to an interface (marked as R_USEIFACE).
3### Go的标记

• /opt/homebrew/Cellar/go@1.24/1.24.10/libexec/src/cmd/internal/objabi/reloctype.go

标记行为发生在Go的ir编译阶段 /opt/homebrew/Cellar/go@1.24/1.24.10/libexec/src/cmd/compile/internal/walk/expr.go

---

• R_USENAMEDMETHOD ： 标记泛型接口调用或通过 MethodByName("F") 查找的方法

比如这里就是对MethodByName的调用的参数进行分析，如果是常量，那么就标记为R_USENAMEDMETHOD，如果不是常量，所在的方法标记为AttrReflectMethod

	if ir.IsConst(targetName, constant.String) {
		name := constant.StringVal(targetName.Val())
		ir.CurFunc.LSym.AddRel(base.Ctxt, obj.Reloc{
			Type: objabi.R_USENAMEDMETHOD,
			Sym:  staticdata.StringSymNoCommon(name),
		})
	} else {
		ir.CurFunc.LSym.Set(obj.AttrReflectMethod, true)
	}

使用了泛型接口调用的函数，由于无法确定Foo的实际上的签名（只有Foo这个名字是确认的，所以也会需要标记上这个R_USENAMEDMETHOD表示在这个函数对Foo这个有重定位（在这个函数可达的情况下，Foo需要保活）

type I[T any] interface{ Foo() T }

// 泛型函数
func f[T any](x I[T]) {
	v := x.Foo()
	fmt.Printf("%T %v\n", v, v)
}

• R_USEIFACEMETHOD ：标记这个函数使用了某个接口类型的某个方法

比如对于不是使用泛型接口方法的，就可以通过这个来精确标记使用了哪个接口的哪个类型

	// dot.Offset() is the method index * PtrSize (the offset of code pointer in itab).
	midx := dot.Offset() / int64(types.PtrSize)
	ir.CurFunc.LSym.AddRel(base.Ctxt, obj.Reloc{
		Type: objabi.R_USEIFACEMETHOD,
		Sym:  TypeLinksym(ityp),
		Add:  InterfaceMethodOffset(ityp, midx),
	})

• R_USEIFACE：标记当前函数中，某个类型被转换为了接口。

1. 函数中出现的转换

// walkConvInterface walks an OCONVIFACE node.
func walkConvInterface(n *ir.ConvExpr, init *ir.Nodes) ir.Node {

	n.X = walkExpr(n.X, init)

	fromType := n.X.Type()
	toType := n.Type()
	if !fromType.IsInterface() && !ir.IsBlank(ir.CurFunc.Nname) {
		// skip unnamed functions (func _())
		if fromType.HasShape() {
			// Unified IR uses OCONVIFACE for converting all derived types
			// to interface type. Avoid assertion failure in
			// MarkTypeUsedInInterface, because we've marked used types
			// separately anyway.
		} else {
			reflectdata.MarkTypeUsedInInterface(fromType, ir.CurFunc.LSym)
		}
	}

2. 全局变量静态赋值中的转换，

会对于全局变量这个符号，标记一下 在A全局变量这个对应的符号中，等于号右边的类型会被转换为接口（标记为R_USEIFACE）

3. 泛型函数实例符号上的标记：
   比如这个函数中其会对于不同函数的实例化，存在很多个实例化函数的符号，比如如果是int，，那么因为这个函数的实例化最终使用返回了接口，所以会绑定这个reloc信息在实例化的AsIface[int]上

func AsIface[T any](v T) Iface { return v }

4. 其他泛型实例中用到的类型也需要标记

• R_USETYPE： 标识类型被使用（不实际重新定位），用于反射可达的类型
  目前只有DWARF的情况下会做这个标记

• R_METHODOFF：类型元数据中的方法元数据，的Ifn和Tfn两个Field对应的函数符号，直接记录下来是标识为R_METHODOFF，根据可达性分析最终写真实偏移还是0，对于其中的Mtyp也是这样。也就是方法类型描述符（abi.Func)

• 普通函数的保活完全依赖常规重定位 + 根集合