{"Prog", Type, 0},
		{"Prog.ProgHeader", Field, 0},
		{"Prog.ReaderAt", Field, 0},
		{"Prog32", Type, 0},
		{"Prog32.Align", Field, 0},
		{"Prog32.Filesz", Field, 0},
		{"Prog32.Flags", Field, 0},
		{"Prog32.Memsz", Field, 0},
		{"Prog32.Off", Field, 0},
		{"Prog32.Paddr", Field, 0},
		{"Prog32.Type", Field, 0},
		{"Prog32.Vaddr", Field, 0},
		{"Prog64", Type, 0},
		{"Prog64.Align", Field, 0},

	if err != nil {
		return nil, err
	}
	for i := 0; i < phnum; i++ {
		off := uintptr(i) * uintptr(phentsize)
		p := new(Prog)
		switch f.Class {
		case ELFCLASS32:
			var ph Prog32
			p.ProgHeader = ProgHeader{
				Type:   ProgType(bo.Uint32(phdata[off+unsafe.Offsetof(ph.Type):])),
				Flags:  ProgFlag(bo.Uint32(phdata[off+unsafe.Offsetof(ph.Flags):])),

	Info      uint32 /* Depends on section type. */
	Addralign uint32 /* Alignment in bytes. */
	Entsize   uint32 /* Size of each entry in section. */
}

// ELF32 Program header.
type Prog32 struct {
	Type   uint32 /* Entry type. */
	Off    uint32 /* File offset of contents. */
	Vaddr  uint32 /* Virtual address in memory image. */
	Paddr  uint32 /* Physical address (not used). */

Than McIntosh <******@****.***> 1634828243 -0400

(MUL x (MOVWconst [1])) => x
(MUL x (MOVWconst [c])) && isPowerOfTwo32(c) => (SLLconst [int32(log32(c))] x)
(MUL x (MOVWconst [c])) && isPowerOfTwo32(c-1) && c >= 3 => (ADDshiftLL x x [int32(log32(c-1))])
(MUL x (MOVWconst [c])) && isPowerOfTwo32(c+1) && c >= 7 => (RSBshiftLL x x [int32(log32(c+1))])
(MUL x (MOVWconst [c])) && c%3 == 0 && isPowerOfTwo32(c/3) => (SLLconst [int32(log32(c/3))] (ADDshiftLL <x.Type> x x [1]))

        %arg30: !tfrt_fallback.tf_tensor, %arg31: !tfrt_fallback.tf_tensor, %arg32: !tfrt_fallback.tf_tensor, %arg33: !tfrt_fallback.tf_tensor, %arg34: !tfrt_fallback.tf_tensor,

pkg debug/elf, type Prog32 struct
pkg debug/elf, type Prog32 struct, Align uint32
pkg debug/elf, type Prog32 struct, Filesz uint32
pkg debug/elf, type Prog32 struct, Flags uint32
pkg debug/elf, type Prog32 struct, Memsz uint32
pkg debug/elf, type Prog32 struct, Off uint32
pkg debug/elf, type Prog32 struct, Paddr uint32
pkg debug/elf, type Prog32 struct, Type uint32

                                       [%newvar, %arg4] as %arg32 : !tf_res_f32)
                  {_mirrored_variable_indices = [0, 1, 2], devices = {TPU_REPLICATED_CORE_0 = ["/device:TPU:0", "/device:TPU:1"]}, n = 2 : i32} {
            // %arg30 is used in the cond function, %arg31 has other uses (%id0), and
            // %arg32 is not a pass-through.
            "tf_device.launch"() ({

	// cond: isPowerOfTwo32(c)
	// result: (SLLconst [int32(log32(c))] x)
	for {
		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
			x := v_0
			if v_1.Op != OpARMMOVWconst {
				continue
			}
			c := auxIntToInt32(v_1.AuxInt)
			if !(isPowerOfTwo32(c)) {
				continue
			}
			v.reset(OpARMSLLconst)
			v.AuxInt = int32ToAuxInt(int32(log32(c)))
			v.AddArg(x)
			return true
		}

	// ppc64x:"ROTL\t[$]10"
	// arm64:"ROR\t[$]54"
	// s390x:"RISBGZ\t[$]0, [$]63, [$]10, "
	// loong64: "ROTRV\t[$]54"
	// riscv64: "RORI\t[$]54"
	a += bits.RotateLeft64(x, 10)

	return a
}

func rot32(x uint32) uint32 {
	var a uint32

	// amd64:"ROLL\t[$]7"
	// arm:"MOVW\tR\\d+@>25"
	// ppc64x:"ROTLW\t[$]7"
	// loong64: "ROTR\t[$]25"
	// riscv64: "RORIW\t[$]25"
	a += x<<7 | x>>25

	// amd64:`ROLL\t[$]8`