FlagTextAddr      = flag.Int64("T", -1, "set the start address of text symbols")
	flagEntrySymbol   = flag.String("E", "", "set `entry` symbol name")
	flagPruneWeakMap  = flag.Bool("pruneweakmap", true, "prune weak mapinit refs")
	flagRandLayout    = flag.Int64("randlayout", 0, "randomize function layout")
	cpuprofile        = flag.String("cpuprofile", "", "write cpu profile to `file`")

				}
			}
			d.markableMethods = append(d.markableMethods, methods...)
		}
	}
}

// mapinitcleanup walks all pkg init functions and looks for weak relocations
// to mapinit symbols that are no longer reachable. It rewrites
// the relocs to target a new no-op routine in the runtime.
func (d *deadcodePass) mapinitcleanup() {
	for _, idx := range d.pkginits {
		relocs := d.ldr.Relocs(idx)

	MAP_ANON                          = 0x1000
	MAP_COPY                          = 0x2
	MAP_FILE                          = 0x0
	MAP_FIXED                         = 0x10
	MAP_HASSEMAPHORE                  = 0x200
	MAP_JIT                           = 0x800
	MAP_NOCACHE                       = 0x400
	MAP_NOEXTEND                      = 0x100
	MAP_NORESERVE                     = 0x40
	MAP_PRIVATE                       = 0x2

}

type FakeVolumePathHandler struct {
	sync.RWMutex
}

func (fv *FakeVolumePathHandler) MapDevice(devicePath string, mapDir string, linkName string, bindMount bool) error {
	// nil is success, else error
	return nil
}

func (fv *FakeVolumePathHandler) UnmapDevice(mapDir string, linkName string, bindMount bool) error {
	// nil is success, else error
	return nil
}

	MAP_ANON                          = 0x1000
	MAP_COPY                          = 0x2
	MAP_FILE                          = 0x0
	MAP_FIXED                         = 0x10
	MAP_HASSEMAPHORE                  = 0x200
	MAP_JIT                           = 0x800
	MAP_NOCACHE                       = 0x400
	MAP_NOEXTEND                      = 0x100
	MAP_NORESERVE                     = 0x40
	MAP_PRIVATE                       = 0x2

			r := l.Key
			r = Expr(r)
			l.Key = AssignConv(r, t.Key(), "map key")

			r = l.Value
			r = Expr(r)
			l.Value = AssignConv(r, t.Elem(), "map value")
		}

		n.SetOp(ir.OMAPLIT)

	case types.TSTRUCT:
		// Need valid field offsets for Xoffset below.
		types.CalcSize(t)

		errored := false
		if len(n.List) != 0 && nokeys(n.List) {
			// simple list of variables
			ls := n.List

	MAP_COPY                                = 0x2
	MAP_FILE                                = 0x0
	MAP_FIXED                               = 0x10
	MAP_HASSEMAPHORE                        = 0x200
	MAP_JIT                                 = 0x800
	MAP_NOCACHE                             = 0x400
	MAP_NOEXTEND                            = 0x100
	MAP_NORESERVE                           = 0x40

		n := n.(*ir.ConvExpr)
		return walkStringToBytesTemp(n, init)

	case ir.OSTR2RUNES:
		n := n.(*ir.ConvExpr)
		return walkStringToRunes(n, init)

	case ir.OARRAYLIT, ir.OSLICELIT, ir.OMAPLIT, ir.OSTRUCTLIT, ir.OPTRLIT:
		return walkCompLit(n, init)

	case ir.OSEND:
		n := n.(*ir.SendStmt)
		return walkSend(n, init)

	case ir.OCLOSURE:
		return walkClosure(n.(*ir.ClosureExpr), init)

	MAP_COPY                                = 0x2
	MAP_FILE                                = 0x0
	MAP_FIXED                               = 0x10
	MAP_HASSEMAPHORE                        = 0x200
	MAP_JIT                                 = 0x800
	MAP_NOCACHE                             = 0x400
	MAP_NOEXTEND                            = 0x100
	MAP_NORESERVE                           = 0x40

description, constructed from these types:

	type wireType struct {
		ArrayT           *ArrayType
		SliceT           *SliceType
		StructT          *StructType
		MapT             *MapType
		GobEncoderT      *gobEncoderType
		BinaryMarshalerT *gobEncoderType
		TextMarshalerT   *gobEncoderType

	}
	type arrayType struct {
		CommonType
		Elem typeId
		Len  int
	}