}
	ctxt := obj.Linknew(architecture.LinkArch)
	ctxt.Debugasm = flags.PrintOut
	ctxt.Debugvlog = flags.DebugV
	ctxt.Flag_dynlink = *flags.Dynlink
	ctxt.Flag_linkshared = *flags.Linkshared
	ctxt.Flag_shared = *flags.Shared || *flags.Dynlink
	ctxt.Flag_maymorestack = flags.DebugFlags.MayMoreStack
	ctxt.Debugpcln = flags.DebugFlags.PCTab
	ctxt.IsAsm = true
	ctxt.Pkgpath = *flags.Importpath

		}
	}

	ctxt.typeMap[h] = append(ctxt.typeMap[h], ctxtEntry{
		orig:     orig,
		targs:    targs,
		instance: inst,
	})

	return inst
}

// getID returns a unique ID for the type t.
func (ctxt *Context) getID(t Type) int {
	ctxt.mu.Lock()
	defer ctxt.mu.Unlock()
	id, ok := ctxt.originIDs[t]
	if !ok {
		id = ctxt.nextID
		ctxt.originIDs[t] = id
		ctxt.nextID++
	}

}

// determineLinkMode sets ctxt.LinkMode.
//
// It is called after flags are processed and inputs are processed,
// so the ctxt.LinkMode variable has an initial value from the -linkmode
// flag and the iscgo, externalobj, and unknownObjFormat variables are set.
func determineLinkMode(ctxt *Link) {
	extNeeded, extReason := mustLinkExternal(ctxt)
	via := ""

	if ctxt.LinkMode == LinkAuto {

	"cmd/link/internal/sym"
)

var sehp struct {
	pdata []sym.LoaderSym
	xdata []sym.LoaderSym
}

func writeSEH(ctxt *Link) {
	switch ctxt.Arch.Family {
	case sys.AMD64:
		writeSEHAMD64(ctxt)
	}
}

func writeSEHAMD64(ctxt *Link) {
	ldr := ctxt.loader
	mkSecSym := func(name string, kind sym.SymKind) *loader.SymbolBuilder {
		s := ldr.CreateSymForUpdate(name, 0)
		s.SetType(kind)

	}

	for _, test := range tests {
		fileIndex, line := ctxt.getFileIndexAndLine(ctxt.PosTable.XPos(test.pos))

		file := "??"
		if fileIndex >= 0 {
			file = ctxt.PosTable.FileTable()[fileIndex]
		}
		got := fmt.Sprintf("%s:%d", file, line)

		if got != test.want {
			t.Errorf("ctxt.getFileSymbolAndLine(%v) = %q, want %q", test.pos, got, test.want)
		}
	}

	ctxt.set_pc(ctxt.pc() + 4)
}

// case 8
func (h *debugCallHandler) debugCallUnsafe(ctxt *sigctxt) {
	sp := ctxt.sp()
	reason := *(*string)(unsafe.Pointer(uintptr(sp) + 40))
	h.err = plainError(reason)
	ctxt.set_pc(ctxt.pc() + 4)
}

// case 16
func (h *debugCallHandler) restoreSigContext(ctxt *sigctxt) {
	// Restore all registers except for pc and sp
	pc, sp := ctxt.pc(), ctxt.sp()
	*ctxt.cregs() = h.sigCtxt.savedRegs

		return false
	}
	if !sigctxtAtTrapInstruction(ctxt) {
		println("trap at non-INT3 instruction pc =", hex(ctxt.sigpc()))
		return false
	}

	switch status := sigctxtStatus(ctxt); status {
	case 0:
		// Frame is ready. Copy the arguments to the frame and to registers.
		// Call the debug function.
		h.debugCallRun(ctxt)
	case 1:
		// Function returned. Copy frame and result registers back out.

		}
	}

	ctxt.typeMap[h] = append(ctxt.typeMap[h], ctxtEntry{
		orig:     orig,
		targs:    targs,
		instance: inst,
	})

	return inst
}

// getID returns a unique ID for the type t.
func (ctxt *Context) getID(t Type) int {
	ctxt.mu.Lock()
	defer ctxt.mu.Unlock()
	id, ok := ctxt.originIDs[t]
	if !ok {
		id = ctxt.nextID
		ctxt.originIDs[t] = id
		ctxt.nextID++
	}

	if ctxt.BuildMode == BuildModePlugin {
		ctxt.Textp = append(ctxt.Textp, amd)
	}
	ctxt.Textp = append(ctxt.Textp, initfunc.Sym())

	// Create an init array entry
	amdi := ctxt.loader.LookupOrCreateSym("go:link.addmoduledatainit", 0)
	initarray_entry := ctxt.loader.MakeSymbolUpdater(amdi)
	ctxt.loader.SetAttrReachable(amdi, true)
	ctxt.loader.SetAttrLocal(amdi, true)
	initarray_entry.SetType(sym.SINITARR)

package obj

import (
	"cmd/internal/goobj"
	"cmd/internal/src"
)

// AddImport adds a package to the list of imported packages.
func (ctxt *Link) AddImport(pkg string, fingerprint goobj.FingerprintType) {
	ctxt.Imports = append(ctxt.Imports, goobj.ImportedPkg{Pkg: pkg, Fingerprint: fingerprint})
}

// getFileIndexAndLine returns the relative file index (local to the CU), and