go/src/cmd/internal/gc/go.go

// Copyright 2009 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package gc

import (
	"bytes"
	"cmd/internal/obj"
)

// Copyright 2009 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

// avoid <ctype.h>

// The parser's maximum stack size.
// We have to use a #define macro here since yacc
// or bison will check for its definition and use
// a potentially smaller value if it is undefined.
const (
	NHUNK    = 50000
	BUFSIZ   = 8192
	NSYMB    = 500
	NHASH    = 1024
	STRINGSZ = 200
	MAXALIGN = 7
	UINF     = 100
	PRIME1   = 3
	AUNK     = 100
	AMEM     = 0 + iota - 9
	AMEM0
	AMEM8
	AMEM16
	AMEM32
	AMEM64
	AMEM128
	ANOEQ
	ANOEQ0
	ANOEQ8
	ANOEQ16
	ANOEQ32
	ANOEQ64
	ANOEQ128
	ASTRING
	AINTER
	ANILINTER
	ASLICE
	AFLOAT32
	AFLOAT64
	ACPLX64
	ACPLX128
	BADWIDTH        = -1000000000
	MaxStackVarSize = 10 * 1024 * 1024
)

const (
	Mpscale = 29
	Mpprec  = 16
	Mpnorm  = Mpprec - 1
	Mpbase  = 1 << Mpscale
	Mpsign  = Mpbase >> 1
	Mpmask  = Mpbase - 1
	Mpdebug = 0
)

type Mpint struct {
	A   [Mpprec]int
	Neg uint8
	Ovf uint8
}

type Mpflt struct {
	Val Mpint
	Exp int16
}

type Mpcplx struct {
	Real Mpflt
	Imag Mpflt
}

type Val struct {
	Ctype int16
	U     struct {
		Reg  int16
		Bval int16
		Xval *Mpint
		Fval *Mpflt
		Cval *Mpcplx
		Sval string
	}
}

type Array struct {
	length   int32
	size     int32
	capacity int32
	data     string
}

type Pkg struct {
	Name     string
	Path     string
	Pathsym  *Sym
	Prefix   string
	Imported uint8
	Exported int8
	Direct   int8
	Safe     bool
	Syms     map[string]*Sym
}

type Sym struct {
	Lexical    uint16
	Flags      uint8
	Sym        uint8
	Link       *Sym
	Uniqgen    uint32
	Importdef  *Pkg
	Linkname   string
	Pkg        *Pkg
	Name       string
	Def        *Node
	Label      *Label
	Block      int32
	Lastlineno int32
	Origpkg    *Pkg
	Lsym       *obj.LSym
}

type Node struct {
	Left           *Node
	Right          *Node
	Ntest          *Node
	Nincr          *Node
	Ninit          *NodeList
	Nbody          *NodeList
	Nelse          *NodeList
	List           *NodeList
	Rlist          *NodeList
	Op             uint8
	Nointerface    bool
	Ullman         uint8
	Addable        uint8
	Trecur         uint8
	Etype          uint8
	Bounded        bool
	Class          uint8
	Method         uint8
	Embedded       uint8
	Colas          uint8
	Diag           uint8
	Noescape       bool
	Nosplit        bool
	Builtin        uint8
	Nowritebarrier bool
	Walkdef        uint8
	Typecheck      uint8
	Local          uint8
	Dodata         uint8
	Initorder      uint8
	Used           uint8
	Isddd          uint8
	Readonly       uint8
	Implicit       uint8
	Addrtaken      uint8
	Assigned       uint8
	Captured       uint8
	Byval          uint8
	Dupok          uint8
	Wrapper        uint8
	Reslice        uint8
	Likely         int8
	Hasbreak       uint8
	Needzero       bool
	Needctxt       bool
	Esc            uint
	Funcdepth      int
	Type           *Type
	Orig           *Node
	Nname          *Node
	Shortname      *Node
	Enter          *NodeList
	Exit           *NodeList
	Cvars          *NodeList
	Dcl            *NodeList
	Inl            *NodeList
	Inldcl         *NodeList
	Closgen        int
	Outerfunc      *Node
	Val            Val
	Ntype          *Node
	Defn           *Node
	Pack           *Node
	Curfn          *Node
	Paramfld       *Type
	Decldepth      int
	Heapaddr       *Node
	Outerexpr      *Node
	Stackparam     *Node
	Alloc          *Node
	Outer          *Node
	Closure        *Node
	Top            int
	Inlvar         *Node
	Pkg            *Pkg
	Initplan       *InitPlan
	Escflowsrc     *NodeList
	Escretval      *NodeList
	Escloopdepth   int
	Sym            *Sym
	InlCost        int32
	Vargen         int32
	Lineno         int32
	Endlineno      int32
	Xoffset        int64
	Stkdelta       int64
	Ostk           int32
	Iota           int32
	Walkgen        uint32
	Esclevel       int32
	Opt            interface{}
}

type NodeList struct {
	N    *Node
	Next *NodeList
	End  *NodeList
}

type Type struct {
	Etype       uint8
	Nointerface bool
	Noalg       uint8
	Chan        uint8
	Trecur      uint8
	Printed     uint8
	Embedded    uint8
	Siggen      uint8
	Funarg      uint8
	Copyany     uint8
	Local       uint8
	Deferwidth  uint8
	Broke       uint8
	Isddd       uint8
	Align       uint8
	Haspointers uint8
	Nod         *Node
	Orig        *Type
	Lineno      int
	Thistuple   int
	Outtuple    int
	Intuple     int
	Outnamed    uint8
	Method      *Type
	Xmethod     *Type
	Sym         *Sym
	Vargen      int32
	Nname       *Node
	Argwid      int64
	Type        *Type
	Width       int64
	Down        *Type
	Outer       *Type
	Note        *string
	Bound       int64
	Bucket      *Type
	Hmap        *Type
	Hiter       *Type
	Map         *Type
	Maplineno   int32
	Embedlineno int32
	Copyto      *NodeList
	Lastfn      *Node
}

type Label struct {
	Used     uint8
	Sym      *Sym
	Def      *Node
	Use      *NodeList
	Link     *Label
	Gotopc   *obj.Prog
	Labelpc  *obj.Prog
	Breakpc  *obj.Prog
	Continpc *obj.Prog
}

type InitEntry struct {
	Xoffset int64
	Key     *Node
	Expr    *Node
}

type InitPlan struct {
	Lit  int64
	Zero int64
	Expr int64
	E    []InitEntry
}

const (
	EscUnknown = iota
	EscHeap
	EscScope
	EscNone
	EscReturn
	EscNever
	EscBits           = 3
	EscMask           = (1 << EscBits) - 1
	EscContentEscapes = 1 << EscBits
	EscReturnBits     = EscBits + 1
)

/*
 * Every node has a walkgen field.
 * If you want to do a traversal of a node graph that
 * might contain duplicates and want to avoid
 * visiting the same nodes twice, increment walkgen
 * before starting.  Then before processing a node, do
 *
 *	if(n->walkgen == walkgen)
 *		return;
 *	n->walkgen = walkgen;
 *
 * Such a walk cannot call another such walk recursively,
 * because of the use of the global walkgen.
 */
var walkgen uint32

const (
	SymExport   = 1 << 0
	SymPackage  = 1 << 1
	SymExported = 1 << 2
	SymUniq     = 1 << 3
	SymSiggen   = 1 << 4
	SymAsm      = 1 << 5
	SymAlgGen   = 1 << 6
)

var dclstack *Sym

type Iter struct {
	Done  int
	Tfunc *Type
	T     *Type
	An    **Node
	N     *Node
}

// Node ops.
const (
	OXXX = iota
	ONAME
	ONONAME
	OTYPE
	OPACK
	OLITERAL
	OADD
	OSUB
	OOR
	OXOR
	OADDSTR
	OADDR
	OANDAND
	OAPPEND
	OARRAYBYTESTR
	OARRAYBYTESTRTMP
	OARRAYRUNESTR
	OSTRARRAYBYTE
	OSTRARRAYBYTETMP
	OSTRARRAYRUNE
	OAS
	OAS2
	OAS2FUNC
	OAS2RECV
	OAS2MAPR
	OAS2DOTTYPE
	OASOP
	OCALL
	OCALLFUNC
	OCALLMETH
	OCALLINTER
	OCALLPART
	OCAP
	OCLOSE
	OCLOSURE
	OCMPIFACE
	OCMPSTR
	OCOMPLIT
	OMAPLIT
	OSTRUCTLIT
	OARRAYLIT
	OPTRLIT
	OCONV
	OCONVIFACE
	OCONVNOP
	OCOPY
	ODCL
	ODCLFUNC
	ODCLFIELD
	ODCLCONST
	ODCLTYPE
	ODELETE
	ODOT
	ODOTPTR
	ODOTMETH
	ODOTINTER
	OXDOT
	ODOTTYPE
	ODOTTYPE2
	OEQ
	ONE
	OLT
	OLE
	OGE
	OGT
	OIND
	OINDEX
	OINDEXMAP
	OKEY
	OPARAM
	OLEN
	OMAKE
	OMAKECHAN
	OMAKEMAP
	OMAKESLICE
	OMUL
	ODIV
	OMOD
	OLSH
	ORSH
	OAND
	OANDNOT
	ONEW
	ONOT
	OCOM
	OPLUS
	OMINUS
	OOROR
	OPANIC
	OPRINT
	OPRINTN
	OPAREN
	OSEND
	OSLICE
	OSLICEARR
	OSLICESTR
	OSLICE3
	OSLICE3ARR
	ORECOVER
	ORECV
	ORUNESTR
	OSELRECV
	OSELRECV2
	OIOTA
	OREAL
	OIMAG
	OCOMPLEX
	OBLOCK
	OBREAK
	OCASE
	OXCASE
	OCONTINUE
	ODEFER
	OEMPTY
	OFALL
	OXFALL
	OFOR
	OGOTO
	OIF
	OLABEL
	OPROC
	ORANGE
	ORETURN
	OSELECT
	OSWITCH
	OTYPESW
	OTCHAN
	OTMAP
	OTSTRUCT
	OTINTER
	OTFUNC
	OTARRAY
	ODDD
	ODDDARG
	OINLCALL
	OEFACE
	OITAB
	OSPTR
	OCLOSUREVAR
	OCFUNC
	OCHECKNIL
	OVARKILL
	OREGISTER
	OINDREG
	OCMP
	ODEC
	OINC
	OEXTEND
	OHMUL
	OLROT
	ORROTC
	ORETJMP
	OEND
)

const (
	Txxx = iota
	TINT8
	TUINT8
	TINT16
	TUINT16
	TINT32
	TUINT32
	TINT64
	TUINT64
	TINT
	TUINT
	TUINTPTR
	TCOMPLEX64
	TCOMPLEX128
	TFLOAT32
	TFLOAT64
	TBOOL
	TPTR32
	TPTR64
	TFUNC
	TARRAY
	T_old_DARRAY
	TSTRUCT
	TCHAN
	TMAP
	TINTER
	TFORW
	TFIELD
	TANY
	TSTRING
	TUNSAFEPTR
	TIDEAL
	TNIL
	TBLANK
	TFUNCARGS
	TCHANARGS
	TINTERMETH
	NTYPE
)

const (
	CTxxx = iota
	CTINT
	CTRUNE
	CTFLT
	CTCPLX
	CTSTR
	CTBOOL
	CTNIL
)

const (
	Cxxx  = 0
	Crecv = 1 << 0
	Csend = 1 << 1
	Cboth = Crecv | Csend
)

// declaration context
const (
	Pxxx = iota
	PEXTERN
	PAUTO
	PPARAM
	PPARAMOUT
	PPARAMREF
	PFUNC
	PDISCARD
	PHEAP = 1 << 7
)

const (
	Etop      = 1 << 1
	Erv       = 1 << 2
	Etype     = 1 << 3
	Ecall     = 1 << 4
	Efnstruct = 1 << 5
	Eiota     = 1 << 6
	Easgn     = 1 << 7
	Eindir    = 1 << 8
	Eaddr     = 1 << 9
	Eproc     = 1 << 10
	Ecomplit  = 1 << 11
)

const (
	BITS = 3
	NVAR = BITS * 64
)

type Bits struct {
	b [BITS]uint64
}

var zbits Bits

type Var struct {
	offset     int64
	node       *Node
	nextinnode *Var
	width      int
	id         int
	name       int8
	etype      int8
	addr       int8
}

var var_ [NVAR]Var

type Typedef struct {
	Name   string
	Etype  int
	Sameas int
}

type Sig struct {
	name   string
	pkg    *Pkg
	isym   *Sym
	tsym   *Sym
	type_  *Type
	mtype  *Type
	offset int32
	link   *Sig
}

type Io struct {
	infile     string
	bin        *obj.Biobuf
	ilineno    int32
	nlsemi     int
	eofnl      int
	last       int
	peekc      int
	peekc1     int
	cp         string
	importsafe bool
}

type Dlist struct {
	field *Type
}

type Idir struct {
	link *Idir
	dir  string
}

/*
 * argument passing to/from
 * smagic and umagic
 */
type Magic struct {
	W   int
	S   int
	Bad int
	Sd  int64
	Sm  int64
	Ud  uint64
	Um  uint64
	Ua  int
}

/*
 * note this is the runtime representation
 * of the compilers arrays.
 *
 * typedef	struct
 * {				// must not move anything
 *	uchar	array[8];	// pointer to data
 *	uchar	nel[4];		// number of elements
 *	uchar	cap[4];		// allocated number of elements
 * } Array;
 */
var Array_array int // runtime offsetof(Array,array) - same for String

var Array_nel int // runtime offsetof(Array,nel) - same for String

var Array_cap int // runtime offsetof(Array,cap)

var sizeof_Array int // runtime sizeof(Array)

/*
 * note this is the runtime representation
 * of the compilers strings.
 *
 * typedef	struct
 * {				// must not move anything
 *	uchar	array[8];	// pointer to data
 *	uchar	nel[4];		// number of elements
 * } String;
 */
var sizeof_String int // runtime sizeof(String)

var dotlist [10]Dlist // size is max depth of embeddeds

var curio Io

var pushedio Io

var lexlineno int32

var lineno int32

var prevlineno int32

var pragcgobuf string

var infile string

var outfile string

var bout *obj.Biobuf

var nerrors int

var nsavederrors int

var nsyntaxerrors int

var decldepth int

var safemode int

var nolocalimports int

var namebuf string

var lexbuf bytes.Buffer
var strbuf bytes.Buffer

var litbuf string

var Debug [256]int

var debugstr string

var Debug_checknil int

var importmyname *Sym // my name for package

var localpkg *Pkg // package being compiled

var importpkg *Pkg // package being imported

var structpkg *Pkg // package that declared struct, during import

var builtinpkg *Pkg // fake package for builtins

var gostringpkg *Pkg // fake pkg for Go strings

var itabpkg *Pkg // fake pkg for itab cache

var Runtimepkg *Pkg // package runtime

var racepkg *Pkg // package runtime/race

var stringpkg *Pkg // fake package for C strings

var typepkg *Pkg // fake package for runtime type info (headers)

var typelinkpkg *Pkg // fake package for runtime type info (data)

var weaktypepkg *Pkg // weak references to runtime type info

var unsafepkg *Pkg // package unsafe

var trackpkg *Pkg // fake package for field tracking

var rawpkg *Pkg // fake package for raw symbol names

var Tptr int // either TPTR32 or TPTR64

var myimportpath string

var idirs *Idir

var localimport string

var asmhdr string

var Types [NTYPE]*Type

var idealstring *Type

var idealbool *Type

var bytetype *Type

var runetype *Type

var errortype *Type

var Simtype [NTYPE]uint8

var (
	Isptr     [NTYPE]bool
	isforw    [NTYPE]bool
	Isint     [NTYPE]bool
	Isfloat   [NTYPE]bool
	Iscomplex [NTYPE]bool
	Issigned  [NTYPE]bool
	issimple  [NTYPE]bool
)

var (
	okforeq    [NTYPE]bool
	okforadd   [NTYPE]bool
	okforand   [NTYPE]bool
	okfornone  [NTYPE]bool
	okforcmp   [NTYPE]bool
	okforbool  [NTYPE]bool
	okforcap   [NTYPE]bool
	okforlen   [NTYPE]bool
	okforarith [NTYPE]bool
	okforconst [NTYPE]bool
)

var (
	okfor [OEND][]bool
	iscmp [OEND]bool
)

var Minintval [NTYPE]*Mpint

var Maxintval [NTYPE]*Mpint

var minfltval [NTYPE]*Mpflt

var maxfltval [NTYPE]*Mpflt

var xtop *NodeList

var externdcl *NodeList

var exportlist *NodeList

var importlist *NodeList // imported functions and methods with inlinable bodies

var funcsyms *NodeList

var dclcontext int // PEXTERN/PAUTO

var incannedimport int

var statuniqgen int // name generator for static temps

var loophack int

var iota_ int32

var lastconst *NodeList

var lasttype *Node

var Maxarg int64

var Stksize int64 // stack size for current frame

var stkptrsize int64 // prefix of stack containing pointers

var blockgen int32 // max block number

var block int32 // current block number

var Hasdefer int // flag that curfn has defer statetment

var Curfn *Node

var Widthptr int

var Widthint int

var Widthreg int

var typesw *Node

var nblank *Node

var Use_sse int

var hunk string

var nhunk int32

var thunk int32

var Funcdepth int

var typecheckok int

var compiling_runtime int

var compiling_wrappers int

var inl_nonlocal int

var use_writebarrier int

var pure_go int

var flag_installsuffix string

var flag_race int

var flag_largemodel int

var noescape bool

var nosplit bool

var nowritebarrier bool

var debuglive int

var Ctxt *obj.Link

var nointerface bool

var writearchive int

var bstdout obj.Biobuf

var Nacl bool

/*
 *	y.tab.c
 */

/*
 *	align.c
 */

/*
 *	array.c
 */

/*
 *	bits.c
 */

/*
 *	mparith1.c
 */

/*
 *	mparith2.c
 */

/*
 *	mparith3.c
 */

/*
 *	obj.c
 */

/*
 *	order.c
 */

/*
 *	range.c
 */

/*
 *	reflect.c
 */

/*
 *	select.c
 */

/*
 *	sinit.c
 */

/*
 *	subr.c
 */

/*
 *	swt.c
 */

/*
 *	typecheck.c
 */

/*
 *	unsafe.c
 */

/*
 *	walk.c
 */

/*
 *	thearch-specific ggen.c/gsubr.c/gobj.c/pgen.c/plive.c
 */
var continpc *obj.Prog

var breakpc *obj.Prog

var Pc *obj.Prog

var firstpc *obj.Prog

var nodfp *Node

var Disable_checknil int

var zerosize int64

/*
 *	racewalk.c
 */

/*
 *	flow.c
 */
type Flow struct {
	Prog   *obj.Prog
	P1     *Flow
	P2     *Flow
	P2link *Flow
	S1     *Flow
	S2     *Flow
	Link   *Flow
	Active int32
	Id     int32
	Rpo    int32
	Loop   uint16
	Refset uint8
	Data   interface{}
}

type Graph struct {
	Start *Flow
	Num   int
	Rpo   []*Flow
}

/*
 *	interface to back end
 */
type ProgInfo struct {
	Flags    uint32
	Reguse   uint64
	Regset   uint64
	Regindex uint64
}

const (
	Pseudo     = 1 << 1
	OK         = 1 << 2
	SizeB      = 1 << 3
	SizeW      = 1 << 4
	SizeL      = 1 << 5
	SizeQ      = 1 << 6
	SizeF      = 1 << 7
	SizeD      = 1 << 8
	LeftAddr   = 1 << 9
	LeftRead   = 1 << 10
	LeftWrite  = 1 << 11
	RegRead    = 1 << 12
	CanRegRead = 1 << 13
	RightAddr  = 1 << 14
	RightRead  = 1 << 15
	RightWrite = 1 << 16
	Move       = 1 << 17
	Conv       = 1 << 18
	Cjmp       = 1 << 19
	Break      = 1 << 20
	Call       = 1 << 21
	Jump       = 1 << 22
	Skip       = 1 << 23
	SetCarry   = 1 << 24
	UseCarry   = 1 << 25
	KillCarry  = 1 << 26
	ShiftCX    = 1 << 27
	ImulAXDX   = 1 << 28
	PostInc    = 1 << 29
)

type Arch struct {
	Thechar        int
	Thestring      string
	Thelinkarch    *obj.LinkArch
	Typedefs       []Typedef
	REGSP          int
	REGCTXT        int
	MAXWIDTH       int64
	Anyregalloc    func() bool
	Betypeinit     func()
	Bgen           func(*Node, bool, int, *obj.Prog)
	Cgen           func(*Node, *Node)
	Cgen_call      func(*Node, int)
	Cgen_callinter func(*Node, *Node, int)
	Cgen_ret       func(*Node)
	Clearfat       func(*Node)
	Defframe       func(*obj.Prog)
	Excise         func(*Flow)
	Expandchecks   func(*obj.Prog)
	Gclean         func()
	Ginit          func()
	Gins           func(int, *Node, *Node) *obj.Prog
	Ginscall       func(*Node, int)
	Igen           func(*Node, *Node, *Node)
	Linkarchinit   func()
	Peep           func(*obj.Prog)
	Proginfo       func(*obj.Prog) ProgInfo
	Regalloc       func(*Node, *Type, *Node)
	Regfree        func(*Node)
	Regtyp         func(*obj.Addr) bool
	Sameaddr       func(*obj.Addr, *obj.Addr) bool
	Smallindir     func(*obj.Addr, *obj.Addr) bool
	Stackaddr      func(*obj.Addr) bool
	Excludedregs   func() uint64
	RtoB           func(int) uint64
	FtoB           func(int) uint64
	BtoR           func(uint64) int
	BtoF           func(uint64) int
	Optoas         func(int, *Type) int
	Doregbits      func(int) uint64
	Regnames       func(*int) []string
}

var pcloc int32

var Thearch Arch

var Newproc *Node

var Deferproc *Node

var Deferreturn *Node

var Panicindex *Node

var panicslice *Node

var throwreturn *Node