t.Error(err)
				continue
			}

			phoff := hdr.Phoff
			phnum := int(hdr.Phnum)
			phsize := uint64(hdr.Phentsize)

			for i := 0; i < phnum; i++ {
				var phdr elf.Prog64
				if err := binary.Read(bytes.NewReader(data[phoff:]), order, &phdr); err != nil {
					t.Error(err)
					continue
				}

				if elf.ProgType(phdr.Type) == elf.PT_NOTE {
					// Increase the size so we keep

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

				Memsz:  uint64(bo.Uint32(phdata[off+unsafe.Offsetof(ph.Memsz):])),
				Align:  uint64(bo.Uint32(phdata[off+unsafe.Offsetof(ph.Align):])),
			}
		case ELFCLASS64:
			var ph Prog64
			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 uint64 /* Alignment in bytes. */
	Entsize   uint64 /* Size of each entry in section. */
}

// ELF64 Program header.
type Prog64 struct {
	Type   uint32 /* Entry type. */
	Flags  uint32 /* Access permission flags. */
	Off    uint64 /* File offset of contents. */
	Vaddr  uint64 /* Virtual address in memory image. */

(MUL x (MOVDconst [1])) => x
(MUL x (MOVDconst [c])) && isPowerOfTwo64(c) => (SLLconst [log64(c)] x)
(MUL x (MOVDconst [c])) && isPowerOfTwo64(c-1) && c >= 3 => (ADDshiftLL x x [log64(c-1)])
(MUL x (MOVDconst [c])) && isPowerOfTwo64(c+1) && c >= 7 => (ADDshiftLL (NEG <x.Type> x) x [log64(c+1)])
(MUL x (MOVDconst [c])) && c%3 == 0 && isPowerOfTwo64(c/3) => (SLLconst [log64(c/3)] (ADDshiftLL <x.Type> x x [1]))

	if a >= C_NONE && a <= C_NCLASS {
		s = cnames9[a]
	}
	var fp string
	fp += s
	return fp
}

func ConstantToCRbit(c int64) (int16, bool) {
	reg64 := REG_CRBIT0 + c
	success := reg64 >= REG_CR0LT && reg64 <= REG_CR7SO
	return int16(reg64), success

	// cond: isPowerOfTwo64(c)
	// result: (ADDshiftLL a x [log64(c)])
	for {
		a := v_0
		x := v_1
		if v_2.Op != OpARM64MOVDconst {
			break
		}
		c := auxIntToInt64(v_2.AuxInt)
		if !(isPowerOfTwo64(c)) {
			break
		}
		v.reset(OpARM64ADDshiftLL)
		v.AuxInt = int64ToAuxInt(log64(c))
		v.AddArg2(a, x)
		return true
	}
	// match: (MADD a x (MOVDconst [c]))

        %arg60: !tfrt_fallback.tf_tensor, %arg61: !tfrt_fallback.tf_tensor, %arg62: !tfrt_fallback.tf_tensor, %arg63: !tfrt_fallback.tf_tensor, %arg64: !tfrt_fallback.tf_tensor,
        %arg65: !tfrt_fallback.tf_tensor, %arg66: !tfrt_fallback.tf_tensor, %arg67: !tfrt_fallback.tf_tensor, %arg68: !tfrt_fallback.tf_tensor, %arg69: !tfrt_fallback.tf_tensor,

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

// license that can be found in the LICENSE file.

package codegen

import "math/bits"

// ------------------- //
//    const rotates    //
// ------------------- //

func rot64(x uint64) uint64 {
	var a uint64

	// amd64:"ROLQ\t[$]7"
	// ppc64x:"ROTL\t[$]7"
	// loong64: "ROTRV\t[$]57"
	// riscv64: "RORI\t[$]57"
	a += x<<7 | x>>57

	// amd64:"ROLQ\t[$]8"
	// arm64:"ROR\t[$]56"